如何为模板类的专用版本添加成员变量？

Question

我有一个模板类，并且至少95％的代码对于所有类型的模板参数都是相同的，除非应该为一个特化添加成员变量和函数。

我想得到的样本如下：

template <typename T>
class AClass {
private:
   T  payLoad;

public:
   AClass( const T& crp_payload ) : payLoad( crp_payload ) {};

   void showMe() {
      cout << "Common showMe:" << payLoad << endl;
   };

   /*
    * A lot of functions same for all specializations go here.
    * I absolutely don't want to implement respectively them for
    * every specializations!
    */

// specializing for int ----------------------------
   // dedicated function
   template <int>
   void showPayload() {
      cout << "AClass<int>::showPayload:" << payLoad << endl;
   };
   // dedicated variable, but following code can not be compiled!
   template <int>
   int   otherPayload;
};

int main() {
   AClass<int> iac( 123 );
   iac.showMe();
   iac.showPayload();//can not pass the compiling!

   AClass<float> fac(456);
   fac.showMe();
   return 0;
};

我的问题：

1. 如何在不重新编码整个AClass<int>的情况下添加“otherPayload”变量？
2. 如何调用showPayload() sinc当我在main()中执行此操作时，我收到错误消息。
3. 有没有办法只专注于“修改/补充”某些成员而没有完全重新实施它？

Answer 1

一种可能的方法是良好的旧继承：

template<class T> struct Extra {};

template<> struct Extra<int> {
    int extraPayload;
    void showPayload();
};

template<class T> class Class: public Extra<T> {
    void showMe();
};

template<> void Class<int>::showMe() { showPayload(); }

所有特定于特定化的部分都在一个单独的类中提取，并且常用方法根据需要进行专门化。

Answer 2

我认为你可以简单地对模板类进行正常的专业化：

#include <iostream>
#include <iomanip>

template <typename T>
class BaseClass 
{
protected:
    T  payLoad;

public:
    BaseClass(const T& crp_payload)
        : payLoad( crp_payload )
    { }

    void showMe() {
        std::cout << "Common showMe:" << payLoad << std::endl;
    }


   /*
    * A lot of functions same for all specializations go here.
    * I absolutely don't want to implement respectively them for
    * every specializations!
    */
};

template <typename T>
class AClass
    : public BaseClass<T> 
{  
public:
    AClass( const T& crp_payload )
        : BaseClass<T>(crp_payload)
    { }

};

// specializing for int ----------------------------
template<>
class AClass<int>
    : public BaseClass<int>
{
public:
    AClass( int crp_payload )
        : BaseClass(crp_payload)
    { }

   // dedicated function
   void showPayload() {
      std::cout << "AClass<int>::showPayload:" << payLoad << std::endl;
   }
private:
   int   otherPayload;
};

int main() {
   AClass<int> iac( 123 );
   iac.showMe();
   iac.showPayload();//can not pass the compiling!

   AClass<float> fac(456);
   fac.showMe();
   return 0;
}