specialization

I'm playing with templates and partial specialization, but there is one specialization I don't know how to write... I'll simplify code to make it easier to read. Let's condiser template <typename T> class x { ... }; Usually, I can specialize like this : class x<a_type> { ... }; Also works with templates types : template <typename T> class x<std::vector<T>> { ... } Now I would like to make the specialization for a type nested in a templated class: template <typename T> class y { struct nested_type { y a_member; }; ... }; // Here comes the specialization template <typename T> class x<y<T>:

I want to specialize a class template with the following function: template <typename T> class Foo { public: static int bar(); }; The function has no arguments and shall return a result based on the type of Foo. (In this toy example, we return the number of bytes of the type, but in the actual application we want to return some meta-data object.) The specialization works for fully specified types: // specialization 1: works template <> int Foo<int>::bar() { return 4; } // specialization 2: works template <> int Foo<double>::bar() { return 8; } // specialization 3: works typedef pair<int, int>

I'm studying the behavior of the C++ linker with respect to template specializations. I'm using Microsoft Visual C++ 2010 for these experiments. I don't know if the behavior is the same with other toolchains (e.g. gcc). Here's a first code snippet: // bar.cpp template <typename T> int foo() { return 1; } int bar() { return foo<double>(); } // main.cpp template <typename T> int foo() { return 1; } template <> int foo<double>() { return 2; } int bar(); int main() { const int x = bar(); const int y = foo<double>(); // doesn't link } Expectedly, this code doesn't link because foo<double>() has

In the sample: #include <iostream> using namespace std; class B { public: virtual void pvf() = 0; }; template <class T> class D : public B { public: D(){} virtual void pvf() {} private: string data; }; template <> class D<bool> : public B { public: D(); virtual void pvf(){ cout << "bool type" << endl; } }; int main() { D<int> d1; D<bool> d2; } I get the following error: test.cpp:(.text+0x1c): undefined reference to `D<bool>::D()' Note that the reason I don't just specialize the D() by itself is I want to eliminate the need for string D<T>::data in the D<bool> case. Why do I need to re

One of my classes declares a templated function: template<class A, class B> A do_something(const std::vector<B> &data) which I'd like to partially specialize on typename A . B is a family of types that implement a pretty minimal interface, and we use a lot of them, so I'd like my specialization to be generic on B . I suspect this is doubly vexing as typename A is used only as the return type. From the internet, I've gleaned that I can't partially specialize a function, so I've created a class as follows: template<class A, class B> class do_something_implementation { public: do_something

I have a templated class and inside I have a templated function( different template parameters ) and I having issues getting the compiler to call the correct one. Example: template< class Parm1, class Parm2, class Parm3 > class Class { public: void Func( Parm1 arg1, Parm2 arg2 ) { Call<Parm3>( arg1, arg2 ); } protected: template< class Type > void Call( Parm1 arg1, Parm2 arg2 ) { } template<> void Call<void>( Parm1 arg1, Parm2 arg2 ) { } }; So if the type of Parm3 is 'void' I want the second Call to be called. Otherwise the first. VS it works fine but GCC pukes all over it. It always calls the

After having found answers to many of my questions on stackoverflow, I have now come up against a question of which I can't find the answer and I hope that someone is willing to help me! My problem is that I want to do an explicit templatization of a function inside a class in C++. My compiler (g++) and a look in the C++ standard (§14.7.3) tells me that this specialization has to be done in the namespace in which the class is declared. I understand that this implies that I cannot put the specialization inside the class, but I don't see the point of this restriction! Does anyone know if there

I have a templated class A<T, int> and two typedefs A<string, 20> and A<string, 30>. How do I override the constructor for A<string, 20> ? The following does not work: template <typename T, int M> class A; typedef A<std::string, 20> one_type; typedef A<std::string, 30> second_type; template <typename T, int M> class A { public: A(int m) {test= (m>M);} bool test; }; template<> one_type::one_type() { cerr << "One type" << endl;} I would like the class A<std::string,20> to do something that the other class doesn't. How can I do this without changing the constructor A:A(int) ? The only thing you