Question

I’m currently refactoring some code the explicitly specializes a member function of a class template with two template parameters.

template <class S, class T>
class Foo
{
  void bar();
};

template <class S, class T>
void Foo<S, T>::bar()
{ /* Generic stuff */ }

template <>
void Foo<SomeType, SomeType>::bar()
{ /* Some special function */ }

Now I added some more template parameters, so the class now looks like this:

template <class S, class EXTRA0, class T, class EXTRA1>
class Foo
{
  void bar();
};

These two extra parameters just add typedefs to my class, so the run-time functionality doesn’t really change. Is there any way I can keep the (now partially) specialized implementation of bar? I can’t seem to figure out the syntax for that and I have a hunch that it might not be possible.

Edit: I’m looking for something like:

template <class EXTRA0, class EXTRA1>
void foo<SomeType, EXTRA0, Sometype, EXTRA1>::bar()
{
   /* specialized implementation */
}

which does not seem to compile..

Answer 1

You are correct, it is not possible.

What you can do is create a helper member class template inside the new Foo, and place the specialized function inside it as a non-template member function. Specialize the helper class instead of the function.

Another alternative is to turn the specialization into a non-template overload.