專注於 C++ 模板中的類型子集

Question

我對 C++ 中的模板專業化有疑問，希望這里有人能提供幫助。 我有一個具有 3 個模板參數的 class：

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

public:
  void myFunc();
};

我想要做的是編寫 myFunc 的幾個版本，專門用於類型 C，但對於類型 A 和 B 是通用的。所以我不想要像這樣的完全模板化的 function：

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

而且我不想要像這樣的完全專業化的 function

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

相反，我想做一些類似於

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. 我已經嘗試了很多不同的模板專業化語法組合（這里列出的太多了），但似乎沒有一個可以編譯。

有人可以在這里指出我正確的方向嗎？ 在此先感謝您的幫助。

邁克爾

Answer 1

您可以編寫一個 function 模板和一個重載，並將工作委托給它：

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(const resolve<int>& )是一個重載的 function，它不是 function 模板的特化。 如果不專門化封閉的 class 模板，就無法專門化成員 function 模板。

閱讀這些文章：

• 模板特化和重載
• 為什么不專門化 Function 模板？

Answer 2

如@Nawaz 所示，在解析器類型上調度是恕我直言的最佳方式。 另一種選擇是將 function 的實際實現移到 class 之外，在它自己的結構內，使其成為 static 並部分專門化該結構。 在 class 內部，調用它。 當然，如果它訪問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);
  }
};

雖然這導致 class 和專用版本中有很多包裝器......

另一個可以說是相當瘋狂的想法是在 class 中沒有函數，而是函子。 那些得到專業化然后被調用。 這更冗長，但可以更好地訪問您想要專門化的功能。 但是，如果他們想訪問私人部分，您現在需要讓他們都成為朋友。 ：/

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