Question

I have a question about template specialization in C++, and I am hoping someone here can help. I have a class that has 3 template parameters:

template<class A, class B, class C>
class myClass {

public:
  void myFunc();
};

What I want to do is write several versions of myFunc that specialize on, say, type C, but are generic for types A and B. So I do NOT want the fully templated function like this:

template<class A, class B, class C>
void myClass<A, B, C>::myFunc()
{
  // function code here
}

and I do NOT want a fully specialized function like this

void myClass<int, int, int>::myFunc()
{
  // code goes here
}

Instead, I want to do something that would be similar to

template<class A, class B>
void myClass<A, B, int>::myFunc()
{
  // code goes here
}

The idea is that if class type C is int, I would call one version of myFunc(), and if class type C is double, I would call a different version of myFunc. I’ve tried lots of difference combinations of template specialization syntaxes (too many to list here), and none seems to compile.

Could someone possibly point me in the right direction here? Thanks in advance for your help.

Michael

Answer 1

You can write a function template, and an overload, and delegate the work to it:

template<class A, class B, class C>
class myClass 
{
   //resolver doesn't need to define anything in it!
   template<class> struct resolver {}; //empty, yet powerful!
public:
  void myFunc() 
  {
       doFun(resolver<C>());
  }

  //this is a function template
  template<typename X>
  void doFun(const resolver<X> & )
  {
      //this function will get executed when C is other than int
      //so write your code here, for the general case
  }

  //this is an overload, not a specialization of the above function template!
  void doFun(const resolver<int> & ) 
  {
      //this function will get executed when C = int
      //so write your code here, for the special case when C = int
  }
};

Note an important point : doFun(const resolve<int>& ) is an overloaded function, its not a specialization of the function template. You cannot specialize member function template without specializing the enclosing class template.

Read these articles:

• Template Specialization and Overloading
• Why Not Specialize Function Templates?