specialization of static method template in class template

Question

is there a way to make this code work?

template<typename T> class test{
public:
    template<typename T2> static void f(){
        cout<<"generic"<<endl;
    }
    template<> static void f<void>(){    //specialization of static method for template T2, within generic class template with argument T
        cout<<"void"<<endl;
    }
};

if not, is it because it counts as a partial template specialization of a function?

http://stackoverflow.com/questions/767477/template-specialization-for-static-member-functions-howto — vulkanino, Jan 27 '12 at 13:00
not what I'm asking. There, struct X is not templated. I tried to move f outside the class definition, but it doesn't work either. — Lorenzo Pistone, Jan 27 '12 at 13:20
Also, see [this][1] post. [1]: http://stackoverflow.com/questions/1723537/template-specialization-of-a-single-method-from-a-templated-class — Brian Lenoski, Jan 27 '12 at 13:29

score 4 · Accepted Answer · answered Jan 27 '12 at 14:52

As others have pointed out in the comments and link, the current C++ template syntax provides no easy way to support this usage. However, if you really want to do this and you don't mind introducing some complexity read on.

The two main problems you have to deal with are:

function templates don't support partial specialization.
partial specialization doesn't work when you define it as part of a class scope.

To get around them and get close to what you're looking for here's what you can try.

move the template definition outside of the class.
define those templates as class functors instead to permit partial spec'ing.

template<typename T>
class test
{
public:
  template <typename T2>
  static void f();
};

template <typename T1, typename T2>
struct f
{
    void operator ()(void) { cout << "generic" << endl; }
};

template <typename T1>
struct f<T1, void>
{
    void operator ()(void) { cout << "void" << endl; }
};

template <typename T>
  template <typename T2>
  void test<T>::f()
  {
    ::f<T, T2>()();
  }

int main()
{
  test<int>::f<int>();      // prints 'generic'
  test<int>::f<void>();     // prints 'void'
}

That's an awful lot of extra code introduced for something like this but I suppose if you want to do this bad enough it's a possibility.

I think I'd use a static member in a helper class, instead of instantiating a functor, but this is the right approach. — Ben Voigt, Jan 27 '12 at 16:16

specialization of static method template in class template

1 Answers1

Linked