C++模版分为函数模版和类模版。其实模版就是一种对类型进行参数化的工具。
 

一、函数模板

1. 函数模板的声明定义

Template<typename/class T1,typename/class T2,….>

返回类型  函数名(函数参数){

     函数体

}

例如：

template<typename T>
T add(T t,T t1)
{
       return t+t1;
}

2. 模板函数的两种调用方式

(1)隐式调用

       int i=1,j=2;
       int k=add(i,j);

默认是add函数的两个参数是同一类型，系统根据实际调用的时候的实参的类型来确定形参的具体类型。注意这里的两个参数类型必须相同。

不可以：

       int i=1,j=2;
       int k=add(1,2.2);//error

(2)显示调用

       int i=1,j=2;
       int k=add<int>(i,j);

首先指定函数模板的具体类型，再去调用。这样就可以：

       int k=add<int>(1,2.3);//OK

二、类模板

1. 类模板的声明定义

Template<typename/class T1, typename/class T2,….>

Class 类名{

类的成员

}

例如：

template<typename T>
class A
{
public:A(T b):a(b){}
          T swap(T& i,T& j){
                 T temp;
                 temp=i;
                 i=j;
                 j=temp;
          }
          void foo(Tt);
private: T a;
};
template<typename T>
void A<T>::foo(T t)
{cout<<t<<endl;}

(1) 注意类模板的成员函数，如果在类外实现，必须在实现的前面加上template<…>。而且函数名前加”类名<T1[,T2,…]>”。

(2)当在类中，想要使用自身类的对象时(例如：copy构造、operator=)时，直接使用类名就可以了。例如：

class A
{
public:A(T b):a(b){}
          A(const A&c){
                 a=c.a;
          }
private: T a;
};

(3)当在类外，想要使用这个类名的时候，必须要“类名+<T,….>”。例如成员函数的类外实现的时候，函数名前加的东西。

class A
{
public:A(T b):a(b){}
          void foo(Ac);
private: T a;
};
template<typename T>
void A<T>::foo(A<T>t)
{cout<<t<<endl;}

(4)有时在类中，想使用同一模板的其他类型的类的对象。例如：

class A
{
public:A(T b):a(b){}
          T getm(){returna;}
          template<typename Y>
          voidfoo(A<Y>& c){
                 cout<<c.getm()<<endl;
          }
private: T a;
};
int _tmain(int argc, _TCHAR* argv[])
{
       A<int> a(2);
       A<double> b(3);
       a.foo(b);
       system("pause");
       return 0;
}

在函数的前面加template<typenameY>,注意这里的Y不能和类模板时的T相同。

这种情况常常在重写copy和operator=时，使用子类的对象给父类的对象copy构造、赋值时，会经常用到这个。具体可见auto_ptr的源码。

2. 类模板的调用

         A<int>a(2);

定义类对象时，先声明类的具体类型。

(1) 和函数模板隐式调用不一样的地方，可以：

template<typename T>
class A
{
public:A(T b):a(b){}
          T add(T t1, T t2)
          {returnt1+t2;}
private: T a;
};
int _tmain(int argc, _TCHAR* argv[])
{
       A<int> a(2);
       a.add(2,3.4);//OK
       system("pause");
       return 0;
}

这里注意类模板的原理：由于类模板在定义的时候，已经确定了T的类型，所以在定义了A<int> a(2)之后，a中的T都变成了int，所以这里add函数就变成了int add(int t1,int t2).这显然就可以add(2,3.4)调用了，符合系统的默认类型转换。

三、非类型形参

当template<typenameT,int In>。出现了int这样的具体类型的时候，In就是非类型形参。例如：

template<typename T,int In>
class A
{
public:A(){a=new T[In];a[0]=3;}
          void foo()
          {cout<<a[0]<<endl;}
          ~A(){delete[]a;}
private: T* a;
};
int _tmain(int argc, _TCHAR* argv[])
{
       A<int,4> a;
       a.foo();
       system("pause");
       return 0;
}

1. 注意非类型形参In在内部是常量值，在上面代码中也可以看出。

2. 非类型形参只能是整型（包括int，short，unsigned int），指针和引用。就是说不可以是float/double/string，但可以是double*/double&/对象的指针、引用也是可以的。

class B{};
template<typename T,doubleIn>class A{};//ERROR
template<typename T,floatIn>class A{};//ERROR
template<typename T,B In>classA{};//ERROR
template<typename T,double&In>class A{};//OK
template<typename T,double*In>class A{};//OK
template<typename T,B* In>classA{};//OK

3. 调用非类型形参的实参必须是一个常量表达式。编译时能计算出结果。（注意sizeof的返回值也是常量，可以使用）

注意：何为常量表达式？(值不会改变，且在编译阶段就能知道确切值的)

const int 、常数、枚举。全局变量的引用/地址、全局对象的引用/地址。

不为常量表达式：

局部变量，局部对象，局部对象的地址/引用，全局变量，全局对象都不是常量表达式。

总结：首先非类型的形参只能是整型，指针，引用。这也决定了实参也必须只能是这些，除此之外，实参还必须是一个常量表达式。所以这样一汇总：实参只能是const int、常数、枚举、全局变量的引用/地址、全局对象的引用/地址。

也可以：

template<int* T>
class A{};
int d[]={2};
int _tmain(int argc, _TCHAR* argv[])
{
       A<d>a;//----------OK
       system("pause");
       return 0;
}

4. 有非类型形参的模板在类外实现成员函数时：

其实对于所有类型的类模板，在类外面定义类的成员时template后面的模板形参应与要定义的类的模板形参一致。

template<int* a>
class A{
public:void foo();
};
template<int* a>  -----在类外不要随便修改a的名称。保持和定义时一致
void A<a>::foo(){}

四、可以为类模板提供类型的默认值

template<typename T=int>
class A{};
int _tmain(int argc, _TCHAR* argv[])
{
       A<>a;//OK
       A<double> b;//OK
       system("pause");
       return 0;
}

1. 注意可以为类模板提供类型默认值，不可以为函数模板提供类型默认值。

template<typename T=int>//ERROR
void foo(){}

2. 注意当有多个类型形参，则从第一个提供默认值的形参后面的形参，都要提供默认值。

template<typename T=int,typename T1>//ERROR
class A{};

五、模板的特化

1. 模板的特化就是给一个已存在的模板进行特殊类型时，执行特别的操作。

template<typename T>
class A{
public:void foo(){cout<<"T"<<endl;}
};
template<>//模板的特化，当T为int时，执行的是这个，当其他类型时，执行的是上面
class A<int>{
public:void foo(){cout<<"int"<<endl;}
};
int _tmain(int argc, _TCHAR* argv[])
{
       A<int> a;//执行的是下面那个特化模板
       a.foo();
       A<double> b;//执行的是上面那个普通模板
       b.foo();
       system("pause");
       return 0;
}

2. 模板的偏特化，也叫部分特化。当模板有多个形参时，对其中一部分进行特化。与上面的全部特化想对应。

//1. 标准模板类。
template<typename T1, typenameT2>
class MyClass {
       ... ...
};
//2. 两个模板参数具有相同类型的部分特化类。
template<typename T>
class MyClass<T,T> {
       ... ...
};
//3. 第二个类型参数是int
template<typename T>
class MyClass<T,int> {
       ... ...
};
//4. 两个模板参数都是指针。
template<typename T1,typenameT2>
classMyClass<T1*,T2*> {
       ... ...
};
//5. 两个模板参数都是相同类型的指针。
template<typename T>
class MyClass<T*,T*>{
       ... ...
};
//6. 模板的全部特化，上面2~5为部分特化
template<>
class MyClass<int,double>{
       ......
};
int _tmain(int argc, _TCHAR* argv[])
{
   MyClass<int,float>c1;         //调用MyClass<T1,T2>
   MyClass<float,float> c2;    //调用MyClass<T,T>
   MyClass<float,int> c3;      //调用MyClass<T,int>
   MyClass<int*,float*>c4;    //调用MyClass<T1*,T2*>
   MyClass<int*,int*>c5;      //调用MyClass<T*,T*>
       MyClass<int,double>c6;      //调用MyClass<int,double>
       system("pause");
       return 0;
}

全部特化一般都是template<>。中括号里没有东西，把所有的形参全部特化。

部分特化一般都是template<T,…>。中括号里有东西，没有把所有的形参都特化。

函数模板同理也可以特化。

六、函数模板的重载

类模板是不可以重载的，而函数模板可以重载。

例子：

template<typename T>
void foo(T)
{cout<<"template"<<endl;}
void foo(int)
{cout<<"foo"<<endl;}
int _tmain(int argc, _TCHAR* argv[])
{
       int i=2;
       double j=2.0;
       foo(i);//调用的是foo(int)------（1）
       foo(j);//调用的是template<>foo(T)----------（2）
       system("pause");
       return 0;
}

和特化类似，只是类模板不可以重载。(废话，类能重载吗)

重载选择的顺序：“越特殊越优先高”

显然如果(1)这么写的话:”foo<int>(i);”就是显式的调用函数模板，这样就调用的tempalte<>foo(T);了。

C++之模板