specializing on a subset of types in a C++ template

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

Nawaz · Accepted Answer · 2011-06-03T15:53:24.003

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:

Thanks for this answer. I think I understand what's going on, and I'm about to try it out. — Michael, Jun 05 '11 at 00:43

Xeo · Answer 2 · 2011-06-03T15:47:42.477

Dispatching on a resolver type as @Nawaz shows is IMHO the best way. Another option would be to move the real implementation of that function outside of the class, inside its own struct, make it static and partially specialize the struct. Inside the class, call that. Of course, if it accesses private parts of myClass, you need to make it friend:

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

template<class A, class B, class C>
struct myClassFuncs{
  typedef myClass<A,B,C> class_type;

  static void myFunc(class_type* self){
    // generic for everything ...
  }
};

template<class A, class B>
struct myClassFuncs<A,B,int>{
  typedef myClass<A,B,int> class_type;

  static void myFunc(class_type* self){
    // specialized on C == int ...
  }
};

// and so on ...

template<class A, class B, class C>
class myClass{
  typedef myClassFuncs<A,B,C> func_holder;
  friend class func_holder;
public:
  void myFunc(){
    func_holder::myFunc(this);
  }
};

Though that leads to a lot of wrappers in the class and the specialized versions...

Another idea, which can be said to be pretty crazy, is to not have functions in the class but functors. Those get specialized and then called. This is more verbose, but allows a better access to which functions you want to specialize. Though, if they want to access private parts, you now need to make all of them friends. :/

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

template<class A, class B, class C>
class myClass_myFunc{
  typedef myClass<A,B,C> class_type;
  class_type* const _self;

public:
  myClass_myFunc(class_type* self)
    : _self(self)
  {}

  void operator() const{
    // generic logic here
  }
};

template<class A, class B>
class myClass_myFunc<A,B,int>{
  typedef myClass<A,B,int> class_type;
  class_type* const _self;

public:
  myClass_myFunc(class_type* self)
    : _self(self)
  {}

  void operator() const{
    // specialized logic here
  }
};

template<class A, class B, class C>
class myClass{
  friend class myClass_myFunc<A,B,C>;
public:
  myClass()
    : myFunc(this)
  {}

  const myClass_myFunc<A,B,C> myFunc;
};

if `myClassFuncs::MyFunc` accesses private members of `myClass`, then you've to make it `friend`. — Nawaz, Jun 03 '11 at 15:40
@Nawaz -Static member functions can access the private part of the class declaration. — Mahesh, Jun 03 '11 at 15:46
@Mahesh: static member functions of the a class can access private members of **that** class only. But here `myClassFuncs` is a different class than `myClass`. — Nawaz, Jun 03 '11 at 15:49
@Nawaz: Right, I had that friend stuff in mind, but seems I forgot it again. Edited. Though, I'm kinda advertising bad practice here, huh? — Xeo, Jun 03 '11 at 15:51
For this particular case, yes. But this approach is useful when you need to *partially* specialize on a set of many template parameters, as function template cannot be partially specialized. — Nawaz, Jun 03 '11 at 15:55

specializing on a subset of types in a C++ template

2 Answers2