C++类模板

一、定义

（1）类模板通常应用于数据结构方面,使得类的实现不在关注数据元素的具体类型,而只关注需要实现的功能

比如: 数组类,链表类,Queue类,Stack类等

（2）类模板和函数模板一样，定义和实现必须都在头文件中

（3）类模板中的成员函数可以在类外进行实现，但是必须加上template<typename T>的声明，以及模板类型的声明

template<typename T>

class MyOperator

{

T OperatorAdd(T objT1, T objT2)

{

    return objT1 + objT2;

}

T OperatorSub(T objT1, T objT2);

};

template<typename T>

T MyOperator<T>::OperatorSub(T objT1, T objT2)

{

    return objT1 - objT2;

}

二、使用

类模板定义对象时，必须制定类模板类型，否则编译器无法推导其类型

MyOperator<int> a;

a.OperatorAdd(10,20);

三、类模板特化

（1）类模板特化和模板函数重载类似，表示可以存在多个相同的类名，但是模板类型不一样

（2）类模板特化分为完全特化和部分特化

（3）完全特化表示显示制定类型参数，模板声明只需写成template<>，并在类名右侧制定参数。

（4）部分特化表示通过特定规则约束类型参数

#include <iostream>

using namespace std; 

template < typename T1,typename T2 >  
class Operator                                            //正常的类模板
{
public:
        void add(T1 a, T2 b)
       {
              cout<<"add(T1 a, T2 b)"<<endl;
              cout<<a+b<<endl;
       }
};

template < typename T >                              
class Operator<T,T>                                //部分特化的类模板,当两个参数都一样,调用这个
{
public:
         void add(T a, T b)
       {
              cout<<"add(T a, T b)"<<endl;
              cout<<a+b<<endl;
       }
};

template < typename T1,typename T2 >  
class Operator<T1*,T2*>                                   //部分特化的类模板,当两个参数都是指针,调用这个
{
public:
        void add(T1* a, T2* b)
       {
              cout<<"add(T1* a, T2* b)"<<endl;
              cout<<*a+*b<<endl;
       }
};

template < >  
class Operator<void*,void*>                             //完全特化的类模板,当两个参数都是void*,调用这个
{
public:
        void add(void* a, void* b)
       {
              cout<<"add(void* a, void* b)"<<endl;
              cout<<"add void* Error"<<endl;                 //void*无法进行加法
       }
};

int main()
{
       int *p1 = new int(1);
       float *p2 = new float(1.25);

       Operator<int,float>  Op1;        //匹配正常的类模板:class Operator      
       Op1.add(1,1.5);

       Operator<int,int>  Op2;          //匹配部分特化的类模板:class Operator<T,T>
       Op2.add(1,4);

       Operator<int*,float*>  Op3;      //匹配部分特化的类模板:class Operator<T1*,T2*>      
       Op3.add(p1,p2);

       Operator<void*,void*>  Op4;      //匹配完全特化的类模板:class Operator<void*,void*>
       Op4.add(NULL,NULL);  

       delete p1;
       delete p2;

       return 0;
}

运行：
add(T1 a, T2 b)
2.5

add(T a, T b)

add(T1* a, T2* b)
2.25

add(void* a, void* b)
add void* Error

四、数值型模板参数

模板参数不仅都是带泛型的(表示不同类型)，还可以是数值型参数，数值型模板参数必须在编译时被唯一确定，变量在运行期间是可变的,所以不能作为模板参数.以及浮点数(不精确),类对象(可变)等等。

例子：通过数值参数的类模板来求 1+2+3+...+N的值

template < int N >
class Sum
{
public:
    static const int VALUE = Sum<N-1>::VALUE + N;              //定义静态常量并赋值
};

template < >
class Sum < 1 >
{
public:
    static const int VALUE = 1;
};

int main()
{
    cout << "1 + 2 + 3 + ... + 10 = " << Sum<10>::VALUE << endl;
    cout << "1 + 2 + 3 + ... + 100 = " << Sum<100>::VALUE << endl;
    return 0;
}

运行打印：

1 + 2 + 3 + ... + 10 = 55
1 + 2 + 3 + ... + 100 = 5050

 

参考：