Как добавить переменную-член для специализированной версии шаблона класса?

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. Как добавить просто переменную "otherPayload" без перекодирования всего AClass<int>
2. Как позвонить showPayload() sinc Когда я получаю сообщение об ошибке, сделайте это в main(), как указано выше.
3. Разве нет пути, только специализируясь на "пересмотре / дополнении" некоторых члены класса без полной его реализации?

Answer 1

Я думаю, что вы можете просто сделать обычную специализацию шаблона-класса:

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

Answer 2

Одним из возможных способов было бы старое доброе наследство:

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

Все специфичные для специализации части извлекаются в отдельный класс, а общие методы специализируются по мере необходимости.