C++模板详解

简介

（1）模板是允许以通用类型的方式来编写程序，其中的通用类型可以是int,double等具体类型。通俗的说使用模板就可以让程序猿编写与类型无关的代码。这种编程方式有时被称为通用编程，而由于类型是参数表示的，因此，模板特性有时也被称为参数化类型。
（2）模板通常有两种形式，一种是函数模板，一种是类模板。
（3）模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在main函数中声明或定义一个模板。

函数模板

模板格式

　template <class 形参名，class 形参名，......> 返回类型 函数名(参数列表) {     函数体 }

以swap函数为例：

template<class T>void swap(T& a,T& b){    T temp;    temp = a;    a = b;    b = temp;}

要建立一个模板，
①关键字template和class是必须的。当然可以使用typename替换class。
②必须使用尖括号。
③类型名T可以任意选择，只要符合Ｃ＋＋的命名规则。

模板使用

函数模板的使用很简单，例如对于swap函数的使用，swap(3,5); 此时编译器就会生成如下代码：

void swap(int& a,int& b){    int temp;    temp = a;    a = b;    b = temp;}

注意：①函数模板不能缩减可执行程序。使用模板的好处是他是生成多个函数的定义更简单。更可靠。
②上面swap如果出现swap(1,2.1)则会则会出现错误。通过声明我们知道swap函数的两个类型应该是一致的。

模板重载

我们可以像重载常规函数那样来重载模板函数。
声明：

template<class T>void swap(T& a,T& b);template<class T>void swap(T* a,T* b,int n);

定义：

template<class T>void swap(T& a,T& b){    int temp;    temp = a;    a = b;    b = temp;}template<class T>void swap(T* a,T* b,int n){    T temp;    for(int i = 0;i < n;i++)    {        temp = a[i];        a[i] = b[i];        b[i] = temp;    }}

注意:①并不是所有的模板参数都必须是模板参数类型，也可以是具体类型。具体类型形参在模板定义的内部是常量值，也就是说具体类型形参在模板的内部是常量。 非类型模板的形参只能是整型，枚举，指针和引用，像int，double, String 这样的类型是不允许的。但是int&，int*，对象的引用或指针是正确的.调用具体类型模板形参的实参必须是一个常量表达式，即它必须能在编译时计算出结果。全局变量的地址或引用，全局对象的地址或引用const类型变量是常量表达式，可以用作非类型模板形参的实参。另外，sizeof表达式的结果是一个常量表达式，也能用作非类型模板形参的实参。另外。模板代码不能修改参数的值，也不能使用参数的地址。
②当模板函数和常规函数都存在时，并且在调用是函数名和参数都符合，那么优先调用的是常规函数。

显示具体化

在使用swap函数时，我们会遇到交换两个对象或者结构体的值，也会遇到交换两个对象或者结构体中某些变量的值，也就是说并不是交换所有变量的值。这种情况下，模板可能就不够用，所以我们可以通过提供一个具体化函数定义来实现需要的功能。这种方式就是显示具体化。
（1）对于给定的函数名，可以有模板函数，常规函数和显示具体化函数以及重载函数。
（2）显示具体化的原型和定义应以template<>开头，并明确指定类型。
（3）具体化将覆盖常规模板，而常规函数将覆盖具体化和常规模板。
以下是三种形式的swap函数:
常规函数：

void swap(int&,int&);

模板函数：

template<class T>void swap(T& a,T& b);

显示具体化：

template<>void swap<int>(int&,int&)

（4）具体化与实例化
①编译器通过模板为特定类型的生成函数定义时，得到的是模板实例。模板并非函数定义，但使用具体类型的模板实例是函数定义。这是实例化方式被称为隐式实例化。想对应的，显示实例化的句法如下:

template void swap<int>(int,int);

上面语句的含义是使用swap模板生成一哥使用int类型的实例，也就是’使用swap模板生成int类型的函数定义’。

②与显示实例化不同，显示具体化的句法如下:

template<> void swap<int>(int&,int&);template<> void swap(int&,int&);

上面的两个声明等价，显示具体化与显示实例化的区别在于，显示具体化它的含义是‘不要使用模板来生成函数定义，而应使用独立的，专门的函数定义显示的为特定类型生成函数定义’。显示具体化，必须有自己的函数定义。显示具体化声明在template后有<>,而显示实例化没有。
③隐式实例化，显示实例化和显示具体化统称为具体化，他们的相同处在于。它们的表示都是使用具体类型的函数定义，而不是通用描述。

调用哪个函数

对于函数重载，函数模板和函数模板重载，我们在调用函数时，编译器到底调用的是哪个函数？？
编译器的这个过程被称为重载解析。具体流程如下：
（1）创建候选函数列表，函数列表包含于被调用函数的名称相同的函数或者模板函数。
（2）利用候选函数列表创建可行函数列表，这些都是函数参数数目正确的函数。这里有个隐式的转化序列，其中包括实参类型与相应的形参类型完全匹配的情况。例如使用float实参可以将float转换为double，从而与double类型形参匹配，就可以使用double类型的模板为float类型生成一个实例。
（3）确定是否有最佳的可行函数。没有则函数调用错误。

参数匹配最佳到最差的顺序如下：
①完全匹配，常规函数优于模板函数。
②提升转换(char,short->int,float->double)
③标准转换(int->char,long->double)
④用户定义的转换，如类声明中定义的转换。

完全匹配的无关紧要转换

实参 形参 Type Type& Type& Type Type[] Type* Type const Type Type volatile Type Type* const Type Type* volatile Type*

在满足完全匹配时，编译器就能找到最佳的调用函数，除非找到多个函数完全匹配。但有两种情况下，编译器仍能完成重载解析。
①指向非const数据的指针和引用优先于非const指针和引用参数匹配。不过，const于非const的区别只适用于指针和引用指向的数据。
②一种是模板函数，另一种是非模板函数。这种情况下，非模板函数优于模板函数。（包括显示具体化）
如果两个完全匹配的函数是两个模板函数，则较具体的模板函数优先，也就是说编译器推断使用哪种类型时，执行的转换最少。

类模板

模板格式

template<class  形参名，class 形参名，…>   class 类名{...};

示例如下：

template<class T>class stack{private:    enum{MAX=10};    T items[MAX];    int top;    int stacksize;public:    stack();    bool isempty();    bool isfull();    bool push(const T& item);    bool pop(T & item);    stack& operator=(const stack& st);}template<class T>stack<T>::stack(){    top = 0;}template<class T>bool stack<T>::isempty(){    return top == 0;}template<class T>bool stack<T>::isfull(){    return top == MAX;}template<class T>bool stack<T>::push(const T& item){    if(top < MAX)    {        items[top++] = item;        return true;    }    else        return false;}template<class T>bool stack<T>::pop(const T& item){    if(top > 0)    {        item = items[--top];        return true;    }    else        return false;}template<class T>stack<T>& stack<T>::operator=(const stack<T>& st){    if(this == &st)        return *this;    delete [] items;    stacksize = st.stacksize;    top = st.top;    items = new T[stacksize];    for(int i = 0;i < top;i++)        items[i] = st.items[i];    return *this;}

模板使用

使用方式如下：

stack<int> test1;stack<string> test2;

特性

（1）可以为类型提供默认值

template<class T1,class T2=int> class test{...};

虽然可以为类模板提供默认类型，但是却不可以为函数模板提供默认类型，但是却可以为二者的非参数类型提供默认值。
（2）递归调用模板

stack< stack<int> > test;

（3）模板可以使用多个类型参数

template<class T1,class T2>class test{...};

模板的具体化

（1）隐式实例化
声明了一个或多个对象，指出所需类型，编译器通过模板生成具体类型的类声明。
（2）显式实例化
当使用template关键字并指出所需类型来声明类时，编译器将生成类声明的显式实例化，实例如下：

template class stack<int>;

这种情况下，虽然没有创建或者提及类对象，编译器也将生成类声明（包括方法定义）。和隐式实例化一样，也将根据通用模板生成具体化。
（3）显示具体化
显示具体化是特性类型（用于替换模板中的通用类型）的定义，有时候，可能需要在为特殊类型实例化时，对模板进行修改，使其行为不同，在这种情况下，可以创建显示实例化。
显示具体化模板格式：

template<> class classname<>{...};

（4）部分具体化

template<class T> class<T,int>{...};

如果有多个模板可供选择，编译器将会选择具体化程度最高的模板。
除了上面的方式，也可以使用指针对模板进行部分具体化。

template<class T>class test{...};template<class T*>class test{...};

如果提供的类型不是指针将会使用上面的模板，如果使用的是指针，将会使用下面的模板。

成员模板

C++中模板可用做结构，类或者模板类的成员。

template <class T>class test{private:    template<class T1>    class test_1    {    private:        T1 val;    public:        test_1(T1 v = 0):val(v){}        void show() const {cout<<val<<endl;}        T1 Value() const {return val;}      };    test_1<T> q;    test_1<int> n;public:    test(T t,int i):q(t),n(i){}    template<class U>    U test2(U u,T t){return ...}    void show() const {q.show();n.show();}};

将模板用作参数

template<template <typenameT> class Thing>class crab{private:    Thing<int> s1;    Thing<double> s2;public:    Crab(){};    bool push(int a,double x){return s1.push(a)&&s2.push(b);}    bool pop(int& a,double& x){return s1.pop(a)&&s2.pop(x);}}int main(){    Crab<stack> test;    test.push(4,3.5);    test.pop(4,3.5);    return 0;}

模板类与友元

模板的友元分三类：
1.非模板友元
2.约束模板友元，即友元的类型取决于类被实例化的类型。
3.非约束模板友元，即友元的所有具体化都是类的每一个具体化的友元。

模板类的非模板友元函数

template<class T>class HasFriend{    friend void counts();};

上面的声明使counts函数成为模板所有实例化的友元。
如果友元函数的参数是模板本身，该怎么定义？？

template<class T>class HasFriend{    friend void counts(HasFriend<T> &);}

上面的声明含义，带HasFriend参数的counts()将成为HasFriend类的友元，同样，带HasFriend参数的counts()函数将是counts的一个重载版本，也是HasFriend类的友元。

模板类的约束模板友元函数

为约束模板友元做准备，要是类的每一个具体化都获得与友元匹配的具体化。具体步骤为三步。
（1）首先，在类定义的前面声明每个模板函数
template void counts();
template void report(T &);
（2）然后在函数中再次将模板声明为友元，这些语句根据类模板的参数的类型声明具体化：

template<class TT>class HasFriend{    friend void counts<TT>();    friend void report<>(HasFriend<TT>&);};

（3）为友元提供模板定义。

模板类的非约束模板友元函数

约束模板友元函数是在类外面声明的模板的具体化。int类具体化获得int函数的具体化，以此类推，通过在类内部声明模板，可以创建非约束友元函数，即每个函数具体化都是每个类的具体化友元。

template<class T>class HasFriend{    template<class C,class D> friend void show(C&,D&);};