专门研究 C++ 中的类型子集。模板

Question

我有一个关于 C++ 中模板专业化的问题，我希望这里有人可以提供帮助。我有一个具有 3 个模板参数的类：

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

public:
  void myFunc();
};

我想要做的是编写 myFunc 的几个版本，这些版本专门针对 C 类型，但对于 A 类型和 B 类型是通用的。所以我不想要像这样的完全模板化函数：

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

并且我不想要像这样的完全专门的函数

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

相反，我想做一些类似于

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

这个想法是，如果类类型 C 是 int，我会调用 myFunc() 的一个版本，并且如果类类型 C是双重的，我会调用不同的版本myFunc 的。我已经尝试了很多不同的模板专业化语法组合（太多，无法在此列出），但似乎没有一个可以编译。

有人可以在这里指出我正确的方向吗？预先感谢您的帮助。

迈克尔

Answer 1

您可以编写一个函数模板和一个重载，并将工作委托给它：

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
  }
};

注意重要的一点：doFun(constresolve&)是一个重载函数，它不是函数模板。如果不专门化封闭类模板，您就无法专门化成员函数模板。

阅读这些文章：

• 模板专业化和重载
• 为什么不专门化函数模板？

Answer 2

正如 @Nawaz 所示，调度解析器类型是恕我直言最好的方法。另一种选择是将该函数的实际实现移到类之外、其自己的结构内，使其静态并部分专门化该结构。在课堂上，这样称呼。当然，如果它访问 myClass 的私有部分，您需要将其设为 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);
  }
};

尽管这会导致类和专用版本中出现大量包装器......

另一个可以说相当疯狂的想法是，类中不包含函数，而使用函子。那些被专门化然后被调用。这比较冗长，但可以更好地访问您想要专门化的功能。不过，如果他们想访问私人部分，你现在需要让他们所有人成为朋友。 :/

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;
};