template-specialization

Consider the following code: template <class x1, class x2 = int*> struct CoreTemplate { }; template <class x1, class x2> struct CoreTemplate<x1*, x2*> { int spec; CoreTemplate() { spec = 1; } }; template <class x> struct CoreTemplate<x*> { int spec; CoreTemplate() { spec = 3; } }; int main(int argc, char* argv[]) { CoreTemplate<int*, int*> qq1; printf("var=%d.\r\n", qq1.spec); CoreTemplate<int*> qq2; printf("var=%d.\r\n", qq2.spec); } MSVC compiles this code fine and selects the second specialization in both cases. For me these specializations are identical. How legal is the second

Suppose I have functions like: template<typename T> inline typename std::enable_if<has_member_foo<T>::value,int>::type foo( T const &t ) { return t.foo(); } template<typename T> inline typename std::enable_if<!has_member_foo<T>::value,int>::type foo( T const& ) { return 0; } template<typename T> inline int call_foo( T const &t ) { return sizeof( T ) + foo( t ); } This mostly works fine, but if I later add an overload for a particular type: inline int foo( std::string const &s ) { return s.size(); } and I add it after the definition of call_foo() , the overload isn't used by call_foo() .

Let's say I have this code template<typename T2, typename T = int> struct X { static double f; }; template<typename T> double X<T>::f = 14.0; If I try to compile clang give me the following error nested name specifier 'X::' for declaration does not refer into a class, class template or class template partial specialization and for GCC : error: template definition of non-template 'double X::f' The question is : Why the compiler want us to specialize the struct X like that : template<typename T2> struct X<T2,int> { static double f; }; The first declaration has int as a default argument, why the

is it possible to write a partial template specialization that is used only for class types that, for example, inherit from a specific class or comply with some other constraint that can be expressed via type traits? i.e., something like this: class A{} class B : public A{} template<typename T> class X{ int foo(){ return 4; } }; //Insert some magic that allows this partial specialization //only for classes which are a subtype of A template<typename T> class X<T>{ int foo(){ return 5; } }; int main(){ X<int> x; x.foo(); //Returns 4 X<A> y; y.foo(); //Returns 5 X<B> z; z.foo(); //Returns 5 X<A*>

Is there a subtle trick for template specialization so that I can apply one specialization to basic POD (when I say basic POD I don't particularly want struct POD (but I will take that)). template<typename T> struct DoStuff { void operator()() { std::cout << "Generic\n";} }; template<> struct DoStuff</*SOme Magic*/> { void operator()() { std::cout << "POD Type\n";} }; Or do I have to write specializations for each of the built in types? template<typename T> struct DoStuff { void operator()() { std::cout << "Generic\n";} }; // Repeat the following template for each of // unsigned long long,

I would like to create a generic vector class and create specializations for a few cases. Something like this (it does not compile, but hopefully communicates my intentions): template<int dim, typename T = float> class Vector { public: typedef Vector<dim, T> VecType; Vector() { /**/ } Vector(const VecType& other) { /**/ ) Vector& operator=(const VecType& other) { /**/ } VecType operator+(const VecType& other) { /**/ } VecType operator-(const VecType& other) { /**/ } T operator*(const VecType& other) { /**/ } private: std::array<T, dim> elements; }; template<int dim, typename T> class Vector<2>