本文作者：黄邦勇帅
学习本文需要对C++的构造函数，C++中的各种类成员，C++中类的继承，有一定的了解。
模板是C++中的重点内容，因此应熟悉C++模板的使用，本文是C++的模板专题，因此本文集中介绍了C++的模板问题，主要介绍了类模板和函数模板的形参与实参(这是学习模板的关键内容)，模板的具体化(特化)方法，模板实参推演，模板函数的匹配，类模板中的模板成员，模板与继承，模板与友元，typename关键字。本文内容全面，简单易懂，是对于学习模板模棱两可的读者的很好的参考文现。
本文内容完全属于个人见解与参考文现的作者无关，其中难免有误解之处，望指出更正。
声明：禁止抄袭本文，若需要转载本文请注明转载的网址，或者注明转载自“黄邦勇帅”。
主要参考文献：
1、C++.Primer.Plus.第五版.中文版[美]Stephen Prata著孙建春韦强译人民邮电出版社2005年5月
2、C++.Primer.Plus.第四版.中文版Stanley B.Lippman、Barbara E.Moo著李师贤等译人民邮电出版社2006年3月
3、C++.Primer.Plus.第三版.中文版Stanley B.Lippman等著潘爱民张丽译中国电力出版社2002年5月
4、C++入门经典第三版[美]Ivor Horton著李予敏译清华大学出版社2006年1月
5、C++参考大全第四版[美]Herbert Schidt著周志荣朱德芳于秀山等译电子工业出版社2003年9月
6、21天学通第四版C++ [美]Jesse Liberty著康博创作室译人民邮电出版社2002年3月
第17章模板
使用模板的目的就是能够让程序员编写与类型无关的代码。比如编写了一个交换两个整型int类型的swap函数，这个函数就只能实现int型，对double，字符这些类型无法实现，要实现这些类型的交换就要重新编写另一个swap函数。使用模板的目的就是要让这程序的实现与类型无关，比如一个swap模板函数，即可以实现int型，又可以实现double型的交换。模板可以应用于函数和类。下面分别介绍
注意：模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在main 函数中声明或定义一个模板。
一、模板函数通式
1、模板函数的通用形式为：template <class 形参名，class 形参名> 反回类型函数名(参数列表){函数体}。其中template
和class是关见字，class可以用typename关见字代替，在这里typename和class没区别，<>括号中的参数叫模板形参，模板形参和函数形参很相像，模板形参不能为空。一但声明了模板函数就可以用模板函数的形参名声明类中的成员变量和成员函数，即可以在该函数中使用内置类型的地方都可以使用模板形参名。模板形参需要调用该模板函数时提供的模板实参来初始化模板形参，一旦编译器确定了实际的模板实参类型就称他实例化了函数模板的一个实例。比如swap的模板函数形式为template <class T> void swap(T& a, T& b){}，当调用这样的模板函数时类型T就会被被调用时的类型所代替，比如swap(a,b)其中a和b是int型，这时模板函数swap中的形参T就会被int所代替，模板函数就变为swap(int &a, int &b)。而当swap(c,d)其中c和d是double类型时，模板函数会被替换为swap(double &a, double &b)，这样就实现了函数的实现与类型无关的代码。
2、注意：对于函数模板而言不存在h(int,int)这样的调用，不能在函数调用的参数中指定模板形参的类型，对函数模板
的调用应使用实参推演来进行，即只能进行h(2,3)这样的调用，或者int a, b; h(a,b)。
二、类模板通式
1．类模板的通用形式为：template<class 形参名，class 形参名…> class 类名{}，类模板和函数模板都是以template 开始后接模板形参列表组成，模板形参不能为空，一但声明了类模板就可以用类模板的形
参名声明类中的成员变量和成员函数，即可以在类中使用内置类型的地方都可以使用模板形参名来声明。比如template<class T> class A{public: T a; T b; T hy(T c, T &d);}；在类A中声明了两个类型为T的成员变量a和b，还声明了一个反回类型为T带两个类型为T的函数hy。
2．类模板对象的创建：比有一个模板类A，则使用类模板创建对象的方法为A<int> m；在类A后面跟上一个<>尖括号并在里面填上相应的类型，这样的话类A中凡是用到模板形参的地方都会被int所代替。当类模板有两个模板形参时创建对象的方法为A<int, double> m；类型之间用逗号隔开。
3、对于类模板，模板形参的类型必须在类名后的尖括号中明确指定。比如A<2> m；用这种方法把模板形参设置为int
是错误的，类模板形参不存在实参推演的问题。也就是说不能把整型值2推演为int型传递给模板形参。要把类模板形参调置为int型必须这样指定A<int> m。
4、在类模板外部定义成员函数的方法为：template<；模板形参列表> 函数反回类型类名<；模板形参名>:：函数名(参数列
表){函数体}，比如有两个模板形参T1，T2的类A中含有一个void h()函数，则定义该函数的语法为：template<class T1,class T2> void A<T1,T2>::h(){}。注意当在类外面定义类的成员时template后面的模板形参应与要定义的类的模板形参一致。
5、再次提醒注意：模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如
不能在main函数中声明或定义一个模板。
三、模板的形数
有三种类型的模板形参：类型形参，非类型形参和模板形参。
1、类型形参
1.1 类型模板形参：类型形参由关见字class或typename后接说明符构成，如template<class T> void h(T a){}；其中T就是
一个类型形参，类型形参的名字由用户自已确定。模板形参表示的是一个未知的类型。模板类型形参可作为类型说明符用在模板中的任何地方，与内置类型说明符或类类型说明符的使用方式完全相同，即可以用于指定反回类型，变量声明等。
1.2 不能为同一个模板类型形参指定两种不同的类型，比如template<class T>void h(T a, T b){}，语句调用h(2, 3.2)将出错，
因为该语句给同一模板形参T指定了两种类型，第一个实参2把模板形参T指定为int，而第二个实参3.2把模板形参指定为double，两种类型的形参不一致，会出错。
2、非类型形参
2.1 非类型模板形参：模板的非类型形参也就是内置类型形参，如template<class T, int a> class B{}；其中int a就是非类型
的模板形参。
2.2 非类型形参在模板定义的内部是常量值，也就是说非类型形参在模板的内部是常量。
2.3 非模板类型的形参只能是整型，指针和引用，像double，String, String **这样的类型是不允许的。但是double &，double
*，对象的引用或指针是正确的。
2.4 调用非类型模板形参的实参必须是一个常量表达式，即他必须能在编译时计算出结果。
2.5 注意：任何局部对象，局部变量，局部对象的地址，局部变量的地址都不是一个常量表达式，都不能用作非类型模
板形参的实参。全局指针类型，全局变量，全局对象也不是一个常量表达式，不能用作非类型模板形参的实参。2.6 全局变量的地址或引用，全局对象的地址或引用const类型变量是常量表达式，可以用作非类型模板形参的实参。2.7 sizeof表达式的结果是一个常量表达式，也能用作非类型模板形参的实参。
2.8 当模板的形参是整型时调用该模板时的实参必须是整型的，且在编译期间是常量，比如template <class T, int a> class
A{}；如果有int b，这时A<int, b> m；将出错，因为b不是常量，如果const int b，这时A<int, b> m；就是正确的，因为这时b是常量。
2.9非类型形参一般不应用于函数模板中，比如有函数模板template<class T, int a> void h(T b){}，若使用h(2)调用会出现
无法为非类型形参a推演出参数的错误，对这种模板函数可以用显示模板实参来解决，如用h<int, 3>(2)这样就把非类型形参a设置为整数3。显示模板实参在后面介绍。
2.9 非类型模板形参的形参和实参间所允许的转换
1、允许从数组到指针，从函数到指针的转换。如：template <int *a> class A{}; int b[1]; A<b> m；即数组到指针的转换
2、const修饰符的转换。如：template<const int *a> class A{}; int b; A<&b> m; 即从int *到const int *的转换。
3、提升转换。如：template<int a> class A{}; const short b=2; A<b> m; 即从short到int的提升转换
4、整值转换。如：template<unsigned int a> class A{}; A<3> m; 即从int到unsigned int的转换。
5、常规转换。
四、类模板的默认模板类型形参
1、可以为类模板的类型形参提供默认值，但不能为函数模板的类型形参提供默认值。函数模板和类模板都可以为模板
的非类型形参提供默认值。
2、类模板的类型形参默认值形式为：template<class T1, class T2=int> class A{}；为第二个模板类型形参T2提供int型的
默认值
3、类模板类型形参默认值和函数的默认参数一样，如果有多个类型形参则从第一个形参设定了默认值之后的所有模板
形参都要设定默认值，比如template<class T1=int, class T2>class A{}；就是错误的，因为T1给出了默认值，而T2没有设定。
4、在类模板的外部定义类中的成员时template后的形参表应省略默认的形参类型。比如template<class T1, class
T2=int>class A{public: void h();}; 定义方法为template<class T1,class T2> void A<T1,T2>::h(){}。
类模板非类型形参示例
//模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在main函数中声明或定义一个模板。//类模板的定义
template<class T>class A{public:T g(T a, T b); A();}; //定义带有一个类模板类型形参T的类A
template<class T1,class T2>class B{public:void g();}; //定义带有两个类模板类型形参T1，T2的类B
//定义类模板的默认类型形参，默认类型形参不适合于函数模板。
template<class T1,class T2=int> class D{public: void g();}; //定义带默认类型形参的类模板。这里把T2默认设置为int型。
//template<class T1=int, class T2>class E{}; //错误，为T1设了默认类型形参则T1后面的所有形参都必须设置认默值。
//以下为非类型形参的定义
指针调用成员函数//非类型形参只能是整型，指针和引用，像double，String, String **这样的类型是不允许的。但是double &，double *对象的引用或指针是正确的。
template<class T1,int a> class Ci{public:void g();}; //定义模板的非类型形参，形参为整型
template<class T1,int&a>class Cip{public:void g();};
template<class T1,A<int>* m> class Cc{public:void g();}; //定义模板的模板类型形参，形参为int型的类A的对象的指针。
template<class T1,double*a>class Cd{public:void g();}; //定义模板的非类型形参，形参为double类型的引用。
class E{};template<class T1,E &m> class Ce{};//非类型模板形参为对象的引用。
//以下非类型形参的声明是错误的。
//template<class T1,A m>class Cc{}; //错误，对象不能做为非类型形参，非类型模板形参的类型只能是对象的引用或指针。
//template<class T1,double a>class Cc{}; //错误，非类型模板的形参不能是double类型，可以是double的引用。
//template<class T1,A<int> m>class Cc{}; //错误，非类型模板的形参不能是对象，必须是对象的引用或指针。这条规则对于模板型参也不例外。
//在类模板外部定义各种类成员的方法，
//typeid(变量名).name()的作用是提取变量名的类型，如int a，则cout<<typeid(a).name()将输出int
template<class T> A<T>::A(){cout<<"class A goucao"<<typeid(T).name()<<endl;} //在类模板外部定义类的构造函数的方法template<class T> T A<T>::g(T a,T b){cout<<"class A g(T a,T b)"<<endl;} //在类模板外部定义类模板的成员
template<class T1,class T2> void B<T1,T2>::g(){cout<<"class g f()"<<typeid(T1).name()<<typeid(T2).name()<<endl;}
//在类外面定义类的成员时template后面的模板形参应与要定义的类的模板形参一致
template<class T1,int a> void Ci<T1,a>::g(){cout<<"class Ci g()"<<typeid(T1).name()<<endl;}
template<class T1,int&a> void Cip<T1,a>::g(){cout<<"class Cip g()"<<typeid(T1).name()<<endl;}
//在类外部定义类的成员时，template后的模板形参应与要定义的类的模板形参一致
template<class T1,A<int> *m> void Cc<T1,m>::g(){cout<<"class Cc g()"<<typeid(T1).name()<<endl;}
template<class T1,double* a> void Cd<T1,a>::g(){cout<<"class Cd g()"<<typeid(T1).name()<<endl;}
//带有默认类型形参的模板类，在类的外部定义成员的方法。
//在类外部定义类的成员时，template的形参表中默认值应省略
template<class T1,class T2> void D<T1,T2>::g(){cout<<"class D g()"<<endl;}
/
/template<class T1,class T2=int> void D<T1,T2>::g(){cout<<"class D k()"<<endl;} //错误，在类模板外部定义带有默认类型的形参时，在template的形参表中默认值应省略。
//定义一些全局变量。
int e=2; double ed=2.2;double*pe=&ed;
A<int> mw;A<int> *pec=&mw; E me;
//main函数开始
int main()
{// template<class T>void h(){} //错误，模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行。//A<2> m; //错误，对类模板不存在实参推演问题，类模板必须在尖括号中明确指出其类型。
//类模板调用实例
A<int> ma; //输出"class A goucao int"创建int型的类模板A的对象ma。
B<int,int> mb; mb.g(); //输出"class B g() int int"创建类模板B的对象mb，并把类型形参T1和T2设计为int
//非类型形参的调用
//调用非类型模板形参的实参必须是一个常量表达式，即他必须能在编译时计算出结果。任何局部对象，局部变量，局部对象的地址，局部变量的地址都不是一个常量表达式，都不能用作非类型模板形参的实参。全局指针类型，全局变量，全局对象也不是一个常量表达式，不能用作非类型模板形参的实参。
//全局变量的地址或引用，全局对象的地址或引用const类型变量是常量表达式，可以用作非类型模板形参的实参。
//调用整型int型非类型形参的方法为名为Ci，声明形式为template<class T1,int a> class Ci
Ci<int,GHIJKLMJKLNOPQMII//正确，数值R是一个int型常量，输出"class Ci g() int"
const int a2=SMITLU int,a2> mci1; mci1.g(); //正确，因为a2在这里是const型的常量。输出"class Ci g() int"
//Ci<int,a> mci; //错误，int型变量a是局部变量，不是一个常量表达式。
//Ci<int,e> mci; //错误，全局int型变量e也不是一个常量表达式。
//调用int&型非类型形参的方法类名为Cip，声明形式为template<class T1,int &a>class Cip
Cip<int,e> mcip; //正确，对全局变量的引用或地址是常量表达式。
//Cip<int,a> mcip1; //错误，局部变量的引用或地址不是常量表达式。
//调用double*类型的非类形形参类名为Cd，声明形式为template<class T1,double *a>class Cd
Cd<int,&ed> mcd; //正确，全局变量的引用或地址是常量表达式。
//Cd<int,pe> mcd1; //错误，全局变量指针不是常量表达式。
//double dd=aNGMIITbULcdefbbHIJKbgMIhh错误，局部变量的地址不是常量表达式，不能用作非类型形参的实参
//Cd<int,&e> mcd; //错误，非类型形参虽允许一些转换，但这个转换不能实现。
//调用模板类型形参对象A<int> *的方法类名为Cc，声名形式为template<class T1,A<int>* m> class Cc
Cc<int,&mw> mcc; mcc.g(); //正确，全局对象的地址或者引用是常量表达式
//Cc<int,&ma> mcc; //错误，局部变量的地址或引用不是常量表达式。
//Cc<int,pec> mcc2; //错误，全局对象的指针不是常量表达式。
//调用非类型形参E&对象的引用的方法类名为Ce。声明形式为template<class T1,E &m> class Ce
E me1;//Ce<int,me1> mce1; //错误，局部对象不是常量表达式
Ce<int,me> mce; //正确，全局对象的指针或引用是常量表达式。
//非类型形参的转换示例，类名为Ci
//非类型形参允许从数组到指针，从函数到指针的转换，const修饰符的转换，提升转换，整值转换，常规转换。
const short s=…M Ci<int,s> mci…MI†//正确，虽然short型和int不完全匹配，但这里可以将short型转换为int型
五、模板的实例化，区别声明，定义，实例化的概恋
1、声明就是让编译器知道有这么一个函数或者类，比如void h(); class A；就声明了一个无参函数h和一
个类A。定义就是
对函数或者类的实现。比如void h(){}，class A{int a;}; 就定义了一个什么也不做的函数h和有一个变量a的类A。2、声明和定义都不会创建实例，只有在使用该函数或者类的时候才会创建一个实例，比如在main函数中调用函数h，
创建类A的对象时都会创建函数h和类A的实例，如果函数h是外部函数则如果在main函数中没有调用函数h，就不会创建函数h的实例。
3、模板的声明，定义，实例化：声明一个模板的形式为template<class T> void h(T a); 或template<class T> class A；这就声
明了一个模板函数h和一个模板类A。注意后面有个分号。模板的定义和函数或类的定义相同。
模板的实例化发生在调用该模板函数和模板类时，比如h(2)或A<int> m；就创建了一个int型的h函数实例和类A的int 实例版本。
当模板被实例化之后就会创建该模板的一个实例，在下次调用到相同的模板实例时就不会生成新的实例，而会调用以前创建的那个实例。比如有模板函数template<class T> void h(T a){}，则有调用h(2)会生成一个int型的模板函数实例，当第二次调用如h(44)时会使用以前生成的int型模板函数实例而不会创建
新的实例。
4、当我们只是声明一个类模板的指针或引用时就没必要知道类模板的定义，也就是说创建类模板的指针或引用时不会创
建类模板的实例，只有指针被解引用或者该问类中的成员时才需要知道类模板的定义，才会实例化该类模板。比如class
A ; A *m; A &n；都不需要知道该类的定义，也不会实例化该类。但是m->a或n->a时就会需要知道该类的定义了，
因为这里指针访问类中的成员，须要类的定义，这时也要创建一个类的实例。
六、模板类型形参与实参间所允许的转换或模板实参推演
1、模板实参推演：当函数模板被调用时，对函数实参类型的检查决定了模板实参的类型和值这个过程叫做模板实参推
演。比如template<class T> void h(T a){}；h(1)；h(2.2)，第一个调用因为实参1是int型的，所以模板形参T被推演为int型，因此函数体中的所有T被替换为int。而第二个调用中double类型的实数3.2决定了T的类型为double。
2、在模板被实例化后就会生成一个新的实例，但这个新生成的实例不存在类型转换。比如有函数模板template<class T>
void h(T a){}。int a=2; short b=3; 第一次调用h(a)生成一个int型的实例版本，但是当用h(b)调用时不会使用上次生成的int实例把short转换为int，而是会另外生成一个新的short型的实例。
3、在模板实参推演的过程中有时类型并不会完全匹配，这时编译器允许以下几种实参到模板形参的转换，这些转换不会
生成新的实例。
3.1、数组到指针的转换或函数到指针的转换：比如template<class T> void h(T * a){}，int b[3]={1,2,3}；h(b)；这时数组
b和类型T *不是完全匹配，但允许从数组到指针的转换因此数组b被转换成int *，而类型形参T被转换成int，也就是说函数体中的T被替换成int。
3.2、限制修饰符转换：即把const或volatile限定符加到指针上。比如template<class T> void h(const T* a){}，int b=3;
h(&b)；虽然实参&b与形参const T*不完全匹配，但因为允许限制修饰符的转换，结果就把&b转换成const int *。
而类形型参T被转换成int。如果模板形参是非const类型，则无论实参是const类型还是非const类型调用都不会产生新的实例。
3.3、到一个基类的转换(该基类根据一个类模板实例化而来)：比如tessmplate<class T1>class A{}; template<class T1>
class B:public A<T1>{}; template<class T2> void h(A<T2>& m){}，在main函数中有B<int> n; h(n)；函数调用的子类对象n与函数的形参A<T2>不完全匹配，但允许到一个基类的转换。在这里转换的顺序为，首先把子类对象n转换为基类对象A<int>，然后再用A<int>去匹配函数的形参A<T2>&，所以最后T2被转换为int，也就是说函数体中的T将被替换为int。
4、再次提醒：对于函数模板而言不存在h(int,int)这样的调用，不能在函数调用的参数中指定模板形参的类型，对函数模
板的调用应使用实参推演来进行，即只能进行h(2,3)这样的调用，或者int a, b; h(a,b)。
模板实参推演示例
//模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在main函数中声明或定义一个模板。//函数模板的定义
template<class T>void h(T a){cout<<"hansu h()"<<typeid(T).name()<<endl;} //带有一个类型形参T的模板函数的定义方法，typeid(变量名).name()为测试变量类型的语句。
template<class T>void k(T a,T b){T c;cout<<"hansu k()"<<typeid(T).name()<<endl;} //注意语句T c。模板类型形参T可以用来声明变量，作为函数的反回类型，函数形参等凡是类类型能使用的地方。
template<class T1,class T2> void f(T1 a, T2 b){cout<<"hansu f()"<<typeid(T1).name()<<","<<typeid(T2).name()<<endl;} //定义带有两个类型形参T1，T2的模板函数的方法
template<class T> void g(const T* a){T b;cout<<"hansu g()"<<typeid(b).name()<<endl;}
//template<class T1,class T2=int> void g(){} //错误，默认模板类型形参不能用于函数模板，只能用于类模板上。
//main函数开始
int main()
{ // template<class T>void h(){} //错误，模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行。
//函数模板实参推演示例。
// h(int); //错误，对于函数模板而言不存在h(int,int)这样的调用，不能在函数调用的参数中指定模板形参的类型，对函数模板的调用应使用实参推演来进行，即只能进行h(2,©Q这样的调用，或者int a, b; h(a,b)。
//h函数形式为：template<class T>void h(T a)
h(2);//输出"hansu h() int"使用函数模板推演，在这里数值2为int型，所以把类型形参T推演为int型。
h(2.¬QMI//输出"hansu h() double"，因为2.®为double型，所以将函数模板的类型形参推演为double型
//k函数形式为：template<class T>void k(T a,T b)
k(2,°QMI//输出"hansu k() int"
//k(2,±N¬QMIhh错误，模板形参T的类型不明确，因为k()函数第一个参数类型为int，第二个为double型，两个形参类型不一致。
//f函数的形式为：template<class T1,class T2> void f(T1 a, T2 b)
f(¶e…N¬QMI//输出"hansu f() int,double"，这里不存在模板形参推演错误的问题，因为模板函数有两个类型形参T1和T2。在这里将T1推演为int，将T2推演为double。
int a=¼M double b=½M
f(a,b); //输出同上，这里用变量名实现推板实参的推演。
//模板函数推演允许的转换示例，g函数的形式为template<class T> void g(const T* a)
int a1ÁÂÃÄÅge†M g(a1); //输出"hansu g() int"，数组的地址和形参const T*不完全匹配，所以将a1的地址T &转换为const T*，而a1是int型的，所以最后T推演为int。
g(&b); //输出"hansu g() double"，这里和上面的一样，只是把类型T转换为double型。
h(&b); }//输出"hansu h() double *"这里把模参类型T推演为double *类型。
七、显示实例化，显示模板实参，显示具体化，模板特化，模板函数重载
7.1 函数模板的显示实例化
1、隐式实例化：比如有模板函数template<class T> void h(T a){}。h(2)这时h函数的调用就是隐式实例化，既参数T的类
型是隐式确定的。
2、函数模板显示实例化声明：其语法是：template 函数反回类型函数名<；实例化的类型> (函数形参表); 注意这是声明
语句，要以分号结束。例如：template void h<int> (int a)；这样就创建了一个h函数的int实例。再如有模板函数template<class T> T h( T a){}，注意这里h函数的反回类型为T，显示实例化的方法为template int h<int>(int a); 把h模板函数实例化为int型。
3、类模板的显示实例化：和函数模板的显示实例化一样都是以template开始。比如template class A<int,int>；将类A显示
实例化为两个int型的类模板。这里要注意显示实例化后面不能有对象名，且以分号结束。
4、显示实例化可以让程序员控制模板实例化发生的时间。
5、对于给定的函数模板实例，显示实例化声明在一个文件中只能出现一次。
6、在显示实例化声明所在的文件中，函数模板的定义必须给出，如果定义不可见，就会发生错误。
7、注意：不能在局部范围类显示实例化模板，实例化模板应放在全局范围内，即不能在main函数等局部范围中实例化
模板。因为模板的声明或定义不能在局部范围或函数内进行。
7.2 显示模板实参
1、显示模板实参：适用于函数模板，即在调用函数时显示指定要调用的时参的类型。
2、格式：显示模板实参的格式为在调用模板函数的时候在函数名后用<>尖括号括住要显示表示的类型，比如有模板函数
template<class T> void h(T a, T b){}。则h<double>(2, 3.2)就把模板形参T显示实例化为double类型。
3、显示模板实参用于同一个模板形参的类型不一致的情况。比如template<class T> void h(T a, T b){}，则h(2, 3.2)的调用
会出错，因为两个实参类型不一致，第一个为int型，第二个为double型。而用h<double>(2, 3.2)就是正
确的，虽然两个模板形参的类型不一致但这里把模板形参显示实例化为double类型，这样的话就允许进行标准的隐式类型转换，即这里把第一个int参数转换为double类型的参数。
4、显示模板实参用法二：用于函数模板的反回类型中。例如有模板函数template<class T1, class T2, class T3> T1 h(T2 a, T3
b){}，则语句int a=h(2,3)或h(2,4)就会出现模板形参T1无法推导的情况。而语句int h(2,3)也会出错。用显示模板实参
就参轻松解决这个问题，比如h<int, int, int>(2,3)即把模板形参T1实例化为int型，T2和T3也实例化为int型。
5、显示模板实参用法三：应用于模板函数的参数中没有出现模板形参的情况。比如template<class T>void h(){}如果在
main函数中直接调用h函数如h()就会出现无法推演类型形参T的类型的错误，这时用显示模板实参就不会出现这种错误，调用方法为h<int>()，把h函数的模板形参实例化为int型，从而避免这种错误。
6、显示模板实参用法四：用于函数模板的非类型形参。比如template<class T,int a> void h(T b){}，而调用h(3)将出错，因
为这个调用无法为非类型形参推演出正确的参数。这时正确调用这个函数模板的方法为h<int, 3>(4)，首先把函数模板的类型形参T推演为int型，然后把函数模板的非类型形参int a用数值3来推演，把变量a设置为3，然后再把4传递给函数的形参b，把b设置为4。注意，因为int a是非类型形参，所以调用非类型形参的实参应是编译时常量表达式，不然就会出错。
6、在使用显示模板实参时，我们只能省略掉尾部的实参。比如template<class T1, class T2, class T3> T1 h(T2 a, T3 b){}在
显示实例化时h<int>(3, 3.4)省略了最后两个模板实参T2和T3，T2和T3由调用时的实参3和3.4隐式确定为int型和double型，而T1被显示确定为int型。h<int, , double><2,3.4>是错误的，只能省略尾部的实参。
7、显示模板实参最好用在存在二义性或模板实参推演不能进行的情况下。
//函数显示模板实参示例适用于函数模板
template<class T>void g1(T a, T b){cout<<"hansu g1()"<<typeid(T).name()<<endl;}
template<class T1,class T2,class TÓHÔg g2(T2a,TÕÖQ
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论