How can I specialize a static member of a template class on a template?

Question

Let's say I have the following class:

template<class T> struct A { static int value; }; template<class T> int A<T>::value = 0; 

I can specialize A::value on a specific type without a problem:

 struct B { }; template<> int A<B>::value = 1; 

I would like to specialize the value of A :: for the template type, I tried the following:

 template<class T> struct C { }; // error: template definition of non-template 'int A<C<T> >::value' template<> template<class T> int A<C<T> >::value = 2; 

Is there a way to do this, or is it possible to specialize the value of A :: for types without templates?

Answer 1

Instead of introducing a whole explicit specialization, you can just specialize initialization

 template<class T> struct Value { static int const value = 0; }; template<class T> struct Value< C<T> > { static int const value = 2; }; template<class T> int A<T>::value = Value<T>::value; 

Answer 2

You can use the partial specialization of A through C:

 #include <iostream> using namespace std; template<class T> struct A { static int value; }; template<class T> int A<T>::value = 0; //(1) define the C template class first: template<class T> struct C { }; //(2) then define the partial specialization of A, in terms of C: template<typename T> struct A<C<T> > { static int value; }; template<typename T> int A<C<T> >::value = 2; int main(void) { cout<<A<C<int> >::value<<endl; cout<<"ok!"<<endl; return 0; } 

Answer 3

Partial specialization with the template template argument (see my comment above):

 #include <iostream> using namespace std; template<class T> struct A { static int value; }; template<class T> int A<T>::value = 0; //solution 2: //define a template-template argument partial specialization //for any generic class U depending on a template argument, //(which is a typename, in this case, but there no reason why //you wouldn't define specializations for non-types, etc.) //this specialization has the advantage of not depending on //the template definition of U (or C, etc.); in this case //both T and U are free to vary, with the only constraint //that U is parameterized by T: template<typename T, template<typename> class U> struct A<U<T> > { static int value; }; template<typename T, template<typename> class U> int A<U<T> >::value = 3; //define the C template class, somewhere, where/when/if needed //possibly in a different namespace, "module" (etc.) template<class T> struct C { }; int main(void) { cout<<A<C<int> >::value<<endl;//this now should print out: 3 cout<<"ok!"<<endl; return 0; }