C++ 部分模板专门化-成员专门化

假设我有这个模板类：

template<typename T> class MyClass{
public:
    MyClass(const T& t):_t(t){}
    ~MyClass(){}
    void print(){ cout << _t << endl; }
private:
    T _t;
};

模板类MyClass{
公众：
MyClass（常量T&T）：\u T（T）{}
~MyClass（）{}
void print（）{cout一个简单的解决方案是，定义包含要专门化的内容的基类模板，然后专门化这个类模板（毕竟它是一个小类）：

模板
结构可打印
{
受保护的：
无效打印（常数T和{}
};
模板
结构可打印
{
受保护的：
无效打印（常数双精度&{}
};

然后从中得出：

template<typename T> 
class MyClass : public printable<T>
{
   typedef printable<T> base;
public:
    MyClass(T t&):_t(t){}
    ~MyClass(){}
    void print(){ base::print(_t); } //forward
private:
    T _t;
};

模板
类MyClass：公共可打印
{
typedef可打印底座；
公众：
MyClass（T&）：\u T（T）{
~MyClass（）{}
void print（）{base:：print（_t）；}//向前
私人：
T_T,；
};

您不需要再专门化这个类模板了；让它尽可能大（并且合理）


另一种方法是将策略类作为模板参数传递给类模板（称为宿主类）

比如说,

//lets define few policy classes
struct cout_print_policy
{
    template<typename T>
    static void print(T const & data)
    {
       std::cout << "printing using cout = " << data << std::endl;
    }
};

struct printf_print_policy
{
    static void print(int data)
    {
       std::printf("printing int using printf = %d\n", data);
    }
    static void print(double data)
    {
       std::printf("printing double using printf = %f\n", data);
    }
};

//now define the class template (called host class) that 
//accepts policy as template argument
template<typename T, typename TPrintPolicy>
class host
{
    typedef TPrintPolicy print_policy;
    T data;
 public:
    host(T const & d) : data(d) {}
    void print() 
    {
        print_policy::print(data);
    }
};

//让我们定义几个策略类
结构无法打印策略
{
模板
静态无效打印（T常量和数据）
{
在您的示例中，您使用的是完全专业化。在这种情况下，您可以这样做：

template <>
void MyClass<double>::print()
{
  cout << _t << endl;
}

模板
void MyClass:：print（）
{
cout您可以专门为双用户指定打印成员函数：



模板<类型名称T>
类MyClass{
公众：
MyClass（T&）：\u T（T）{
~MyClass（）{}
无效打印（）{}
私人：
T_T,；
};
模板<类型名称T>
void MyClass< T>:：print（）{/*您的特定实现*/}
模板<>
void MyClass< double>:：print（）{/*您的特定实现*/}

在h班

// declaration of template class
template<typename T>
class MyClass
{
public:
    MyClass(T t&):_t(t){}
    ~MyClass(){}
    void print();    // general "declaration". 
                     // don't use inline definition for these case
private:
    T _t;
};

// specialization "declaration" of wanted member function
template<>
void MyClass<double>::print();

#include "class.inl" // implementation of template class

//模板类的声明
模板
类MyClass
{
公众：
MyClass（T&）：\u T（T）{
~MyClass（）{}
void print（）；//一般“声明”。
//对于这些情况，不要使用内联定义
私人：
T_T,；
};
//所需成员函数的专门化“声明”
模板
void MyClass:：print（）；
#包括“class.inl”//模板类的实现

在class.inl中

// general "definition" of wanted member function
template<typename T>
void MyClass<T>::print()
{
    cout << _t << endl;
}

//所需成员函数的一般“定义”
模板
void MyClass:：print（）
{
很多人会使用模板来避免类继承吗？为什么你会建议他使用继承，而不是像他所问的那样仅仅展示如何专门化一个成员函数？@tenfour:我想，在他的真实代码中，他没有更多的东西需要专门化，包括数据成员。@tenfour:因为这是解决问题的简单而标准的方法M
template <>
void MyClass<double>::print()
{
  cout << _t << endl;
}

template< typename T >
class MyClass{
public:
       MyClass(T t&):_t(t){}
    ~MyClass(){}
    void print(){}
private:
    T _t;
};
template< typename T >
void MyClass< T >::print(){/* your specific implementation*/}

template<>
void MyClass< double >::print(){/* your specific implementation*/}
// declaration of template class
template<typename T>
class MyClass
{
public:
    MyClass(T t&):_t(t){}
    ~MyClass(){}
    void print();    // general "declaration". 
                     // don't use inline definition for these case
private:
    T _t;
};

// specialization "declaration" of wanted member function
template<>
void MyClass<double>::print();

#include "class.inl" // implementation of template class

// general "definition" of wanted member function
template<typename T>
void MyClass<T>::print()
{
    cout << _t << endl;
}

#include "class.h"

// specialization "definition" of wanted member function
// specialization definition of anyone must be here.. not inl file..
void MyClass<double>::print()
{
    cout << "double specialization " << _t << endl;
}