problem instantiating template with pointers
I can't figure out why this won't compile:
any ideas?Code:template <class T, T init = T()> class test { }; int main(void) { test<int, 1024> a; /* ok */ test<int> b; /* ok */ test<int*, 0> c; /* no */ test<int*> d; /* ok / no (depends on the compiler) */ }
Code:#include <cmath> #include <complex> bool euler_flip(bool value) { return std::pow ( std::complex<float>(std::exp(1.0)), std::complex<float>(0, 1) * std::complex<float>(std::atan(1.0) *(1 << (value + 2))) ).real() < 0; }
MSVC 2003 doesn't seem to mind. Perhaps it doesn't like converting 0 to a pointer? Try NULL, or (int *)0.
I tried that too, but with mixed results...
Code:#include <cmath> #include <complex> bool euler_flip(bool value) { return std::pow ( std::complex<float>(std::exp(1.0)), std::complex<float>(0, 1) * std::complex<float>(std::atan(1.0) *(1 << (value + 2))) ).real() < 0; }
What's the error message? With Comeau online it is:which would seem to indicate skorman00 is correct. The (int *)0 fixes it there.Code:"ComeauTest.c", line 7: error: argument of type "int" is incompatible with template parameter of type "int *" test<int*, 0> c; /* no */
o.k., thanks. but mingw still won't compile what you guys suggested nor the last two examples I posted - the complaint is: 'a casts to a type other than an integral or enumeration type cannot appear in a constant-expression'. not sure, but it may be something in the standard (which mingw sticks pretty close to). I wonder if there's a workaround for that?
Code:#include <cmath> #include <complex> bool euler_flip(bool value) { return std::pow ( std::complex<float>(std::exp(1.0)), std::complex<float>(0, 1) * std::complex<float>(std::atan(1.0) *(1 << (value + 2))) ).real() < 0; }
I would imagine it would be a bug in the compiler. VC++ 2003 and Comeau are fairly standards compliant themselves, and since 0 is a valid pointer you should be able to use it there.
So it doesn't compile d above? What is the error when you only try d?
it says: ' "0u" is not a valid template argument - it must be the address of an object with external linkage'.
>> I would imagine it would be a bug in the compiler.
it could very well be. but mingw is one of the strictest compilers out there - in fact, I've noticed that if something compiles with mingw, it will probably compile with any other compiler. not that it doesn't have it's share of bugs - it does (there have been a few internal compiler errors using templates I've come across), but all in all it seems to follow the standard to a 'T', making it a great tool for writing portable code. another thing I noticed with this particular project is mingw won't let you use operator delete on a void*. It seems to me that in both of these cases the compiler should have issued a warning instead of an error...odd.
Code:#include <cmath> #include <complex> bool euler_flip(bool value) { return std::pow ( std::complex<float>(std::exp(1.0)), std::complex<float>(0, 1) * std::complex<float>(std::atan(1.0) *(1 << (value + 2))) ).real() < 0; }
I would search over in comp.lang.c++.moderated if you haven't already, and consider asking about this there if you don't find anything. Compiler writers themselves often answer there, so you are more likely to get a good explanation. I'm not sure I even want to try to figure out where to look in the standard for such an issue.
well said.
Code:#include <cmath> #include <complex> bool euler_flip(bool value) { return std::pow ( std::complex<float>(std::exp(1.0)), std::complex<float>(0, 1) * std::complex<float>(std::atan(1.0) *(1 << (value + 2))) ).real() < 0; }
I don't know why I chose to wander into the standard for this other than just curiousity. A bit I happened upon (14.3.2p5):FWIWfor a non-type template-parameter of type pointer to object, qualification conversions (4.4) and the array-to-pointer conversion (4.2) are applied. [Note: In particular, neither the null pointer conversion (4.10) nor the derived-to-base conversion (4.10) are applied. Although 0 is a valid template-argument for a non-type template-parameter of integral type, it is not a valid template-argument for a non-type template-parameter of pointer type. ]
7. It is easier to write an incorrect program than understand a correct one.
40. There are two ways to write error-free programs; only the third one works.*
ah, so basically, even though it compiles on some compilers, it shouldn't. but I'm confused about the default template parameter now...calling a constructor isn't exactly a constant expression - I wonder if that's invalid, too? anyway, thanks for looking that up, Dave.
Code:#include <cmath> #include <complex> bool euler_flip(bool value) { return std::pow ( std::complex<float>(std::exp(1.0)), std::complex<float>(0, 1) * std::complex<float>(std::atan(1.0) *(1 << (value + 2))) ).real() < 0; }
