c++ 模板

C++模板模板是 C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。模板是一种对类型进行参数化的工具；通常有两种形式： 函数模板和类模板；函数模板针对仅参数类型不同的函数；类模板针对仅数据成员和成员函数类型不同的类。使用模板的目的就是能够让程序员编写与类型无关的代码。 比如编写了一个交换两个整型 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)。函数模板的示例演示将在下文中涉及！int 型二、类模板通式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 是错误的（ 编译错误： error C2079: 'a' uses undefined class'A<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，两种类型的形参不一致，会出错。（针对函数模板）作者原版： 1.2 针对函数模板是正确的，但是忽略了类模板。下面将对类模板的情况进行补充。本人添加 1.2 补充版（针对于类模板）、 当我们声明类对象为： A<int> a，比如template<class T>T g(T a, T b){}，语句调用 a.g(2, 3.2)在编译时不会出错，但会有警告，因为在声明类对象的时候已经将 T 转换为 int 类型，而第二个实参 3.2 把模板形参指定为 double，在运行时，会对 3.2 进行强制类型转换为 3。当我们声明类的对象为： A<double> a,此时就不会有上述的警告，因为从 int 到 double 是自动类型转换。演示示例１：TemplateDemo.h1 #ifndef TEMPLATE_DEMO_HXX2 #define TEMPLATE_DEMO_HXX3 4template<class T> class A{5 public:6 T g(T a,T b);7 A();8 };910 #endifTemplateDemo.cpp1 #include<iostream.h>2 #include "TemplateDemo.h"3 4template<class T> A<T>::A(){}5 6template<class T> T A<T>::g(T a,T b){7 return a+b;8 }910 void main(){11 A<int> a;12 cout<<a.g(2,3.2)<<endl;13 }编译结果：1 --------------------Configuration: TemplateDemo - Win32 Debug--------------------2 Compiling...3 TemplateDemo.cpp4 G:\C++\CDaima\TemplateDemo\TemplateDemo.cpp(12) : warning C4244: 'argument' :conversion from 'const double' to 'int', possible loss of data5 6TemplateDemo.obj - 0 error(s), 1 warning(s)运行结果： 5我们从上面的测试示例中可以看出，并非作者原作中的那么严密！此处仅是本人跟人测试结果！请大家本着实事求是的态度，自行验证！2、非类型形参2.1 、非类型模板形参： 模板的非类型形参也就是内置类型形参，如 template<classT, 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, inta> void h(T b){}，若使用 h(2)调用会出现无法为非类型形参 a 推演出参数的错误，对这种模板函数可以用显示模板实参来解决，如用 h<int, 3>(2)这样就把非类型形参 a 设置为整数 3。显示模板实参在后面介绍。2.10、 非类型模板形参的形参和实参间所允许的转换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：由用户自己亲自指定栈的大小，并实现栈的相关操作。TemplateDemo.h1 #ifndef TEMPLATE_DEMO_HXX2 #define TEMPLATE_DEMO_HXX3 4template<class T,int MAXSIZE> class Stack{//MAXSIZE 由用户创建对象时自行设置5 private:6 T elems[MAXSIZE]; // 包含元素的数组7 int numElems; // 元素的当前总个数8 public:9 Stack(); //构造函数10 void push(T const&); //压入元素11 void pop(); //弹出元素12 T top() const; //返回栈顶元素13 bool empty() const{ // 返回栈是否为空14 return numElems == 0;15 }16 bool full() const{ // 返回栈是否已满17 return numElems == MAXSIZE;18 }19 };2021 template <class T,int MAXSIZE>22 Stack<T,MAXSIZE>::Stack():numElems(0){ // 初始时栈不含元素23 // 不做任何事情24 }2526 template <class T,int MAXSIZE>27 void Stack<T, MAXSIZE>::push(T const& elem){28 if(numElems == MAXSIZE){29 throw std::out_of_range("Stack<>::push(): stack is full");30 }31 elems[numElems] = elem; // 附加元素32 ++numElems; // 增加元素的个数33 }3435 template<class T,int MAXSIZE>36 void Stack<T,MAXSIZE>::pop(){37 if (numElems <= 0) {38 throw std::out_of_range("Stack<>::pop(): empty stack");39 }40 --numElems; // 减少元素的个数41 }4243 template <class T,int MAXSIZE>44 T Stack<T,MAXSIZE>::top()const{45 if (numElems <= 0) {46 throw std::out_of_range("Stack<>::top(): empty stack");47 }48 return elems[numElems-1]; // 返回最后一个元素49 }5051 #endifTemplateDemo.cpp1 #include<iostream.h>2 #include <iostream>3 #include <string>4 #include <cstdlib>5 #include "TemplateDemo.h"6 7int main(){8 try {9 Stack<int,20> int20Stack; // 可以存储 20 个 int 元素的栈10 Stack<int,40> int40Stack; // 可以存储 40 个 int 元素的栈11 Stack<std::string,40> stringStack; // 可存储 40 个 string 元素的栈1213 // 使用可存储 20 个 int 元素的栈14 int20Stack.push(7);15 std::cout << int20Stack.top() << std::endl; //716 int20Stack.pop();1718 // 使用可存储 40 个 string 的栈19 stringStack.push("hello");20 std::cout << stringStack.top() << std::endl; //hello21 stringStack.pop();22 stringStack.pop(); //Exception: Stack<>::pop<>: empty stack23 return 0;24 }25 catch (std::exception const& ex) {26 std::cerr << "Exception: " << ex.what() << std::endl;27 return EXIT_FAILURE; // 退出程序且有 ERROR 标记28 }29 }运行结果：非类型形参演示示例 2：TemplateDemo01.h1 #ifndef TEMPLATE_DEMO_O12 #define TEMPLATE_DEMO_0134 template<typename T> class CompareDemo{5 public:6 int compare(const T&, const T&);7 };8 9template<typename T>10 int CompareDemo<T>::compare(const T& a,const T& b){11 if((a-b)>0)12 return 1;13 else if((a-b)<0)14 return -1;15 else16 return 0;17 }1819 #endifTemplateDemo01.cpp1 #include<iostream.h>2 #include "TemplateDemo01.h"3 4void main(){5 CompareDemo<int> cd;6 cout<<cd.compare(2,3)<<endl;7 }运行结果： -11 #include<iostream.h>2 #include "TemplateDemo01.h"3 4void main(){5 CompareDemo<double> cd;6 cout<<cd.compare(3.2,3.1)<<endl;7 }运行结果： 1TemplateDemo01.h 改动如下：1 #ifndef TEMPLATE_DEMO_O12 #define TEMPLATE_DEMO_013 4template<typename T> class CompareDemo{5 public:6 int compare(T&, T&);7 };8 9template<typename T>10 int CompareDemo<T>::compare(T& a,T& b){11 if((a-b)>0)12 return 1;13 else if((a-b)<0)14 return -1;15 else16 return 0;17 }1819 #endifTempalteDemo01.cpp1 #include<iostream.h>2 #include "TemplateDemo01.h"3 4void main(){5 CompareDemo<int> cd;6 int a=2,b=3;7 cout<<cd.compare(a,b)<<endl;8 }非类型形参演示示例 3：TemplateDemo02.cpp1 #include<iostream.h>2 3template<typename T>4 const T& max(const T& a,const T& b){5 return a>b ? a:b;6 }7 8void main(){9 cout<<max(2.1,2.2)<<endl;//模板实参被隐式推演成 double10 cout<<max<double>(2.1,2.2)<<endl;//显示指定模板参数。11 cout<<max<int>(2.1,2.2)<<endl;//显示指定的模板参数，会将函数函数直接转换为 int。12 }运行结果：cout<<max<int>(2.1,2.2)<<endl;//显示指定的模板参数，会将函数函数直接转换为 int。 此语句会出现警告：按 Ctrl+C 复制代码　　warning C4244: 'argument' : conversion from 'const double' to 'const int', posG:\C++\CDaima\TemplateDemo02\TemplateDemo02.cpp(11) :　　warning C4244: 'argument' : conversion from 'const double' to 'const int', posTemplateDemo02.obj - 0 error(s), 2 warning(s)按 Ctrl+C 复制代码四、类模板的默认模板类型形参1、可以为类模板的类型形参提供默认值，但不能为函数模板的类型形参提供默认值。函数模板和类模板都可以为模板的非类型形参提供默认值。2、类模板的类型形参默认值形式为： template<class T1, class T2=int> class A{};为第二个模板类型形参 T2 提供 int 型的默认值。3、类模板类型形参默认值和函数的默认参数一样，如果有多个类型形参则从第一个形参设定了默认值之后的所有模板形参都要设定默认值，比如 template<class T1=int, classT2>class A{};就是错误的，因为 T1 给出了默认值，而 T2 没有设定。4、在类模板的外部定义类中的成员时 template 后的形参表应省略默认的形参类型。比如 template<class T1, class T2=int> class A{public: void h();}; 定义方法为 template<classT1,class T2> void A<T1,T2>::h(){}。定义类模板类型形参：演示实例 1：TemplateDemo.h1 #ifndef TEMPLATE_DEMO_HXX2 #define TEMPLATE_DEMO_HXX3 4template<class T> class A{5 public:6 T g(T a,T b);7 A();8 };910 #endifTemplateDemo.cpp1 #include<iostream.h>2 #include "TemplateDemo.h"3 4template<class T> A<T>::A(){}5 6template<class T> T A<T>::g(T a,T b){7 return a+b;8 }910 void main(){11 A<int> a;12 cout<<a.g(2,3)<<endl;13 }运行结果： 5类模板的默认模板类型形参示例 1：TemplateDemo03.h1 #ifndef TEMPLATE_DEMO_032 #define TEMPLATE_DEMO_033 //定义带默认类型形参的类模板。这里把 T2 默认设置为 int 型。4 template<class T1,class T2=int> class CeilDemo{5 public:6 int ceil(T1,T2);7 };8 //在类模板的外部定义类中的成员时 template 后的形参表应省略默认的形参类型。9 template<class T1,class T2>10 int CeilDemo<T1,T2>::ceil(T1 a,T2 b){11 return a>>b;12 }1314 #endifTemplateDemo03.cpp1 #include<iostream.h>2 #include "TemplateDemo03.h"3 4void main(){5 CeilDemo<int> cd;6 cout<<cd.ceil(8,2)<<endl;7 }运行结果： 2在类模板的外部定义类中的成员时 template 后的形参表应省略默认的形参类型，如果没有省略，不会出现编译错误而是提出警告：1 --------------------Configuration: TemplateDemo03 - Win32 Debug--------------------2 Compiling...3 TemplateDemo03.cpp4 g:\c++\cdaima\templatedemo03\templatedemo03.h(12) :5 warning C4519: default template arguments are only allowed on a class template; ignored6 7TemplateDemo03.obj - 0 error(s), 1 warning(s)原作者： 类模板类型形参默认值和函数的默认参数一样，如果有多个类型形参则从第一个形参设定了默认值之后的所有模板形参都要设定默认值，比如 template<class T1=int, classT2>class A{};就是错误的，因为 T1 给出了默认值，而 T2 没有设定。实例测试如下：类模板的默认模板类型形参示例 2：TemplateDemo03.h1 #ifndef TEMPLATE_DEMO_032 #define TEMPLATE_DEMO_033 4template<class T1=int,class T2,class T3> class CeilDemo{5 public:6 int ceil(T1,T2,T3);7 };8 9template<class T1,class T2,class T3>10 int CeilDemo<T1,T2,T3>::ceil(T1 a,T2 b,T3 c){11 return a+b+c;12 }1314 #endifTemplateDemo03.cpp1 #include<iostream.h>2 #include "TemplateDemo03.h"3 4void main(){5 CeilDemo<int,int> cd;6 cout<<cd.ceil(2,3,4)<<endl;7 }运行结果： 9上例中我们看到，虽然多个类型形参则从第一个形参 T1 设定了默认值为 int 类型，但后面的两个并没有设定默认值。我们在声明对象的时候指明了 T2 和 T3 的类型都为 int 类型，编译、运行没有任何警告和错误。但并不能否定原作者是错的，这只是一个特例，看下面的示例：类模板的默认模板类型形参示例 3：TemplateDemo03.h1 #ifndef TEMPLATE_DEMO_032 #define TEMPLATE_DEMO_033 4template<class T1=int,class T2,class T3> class CeilDemo{5 public:6 double ceil(T1,T2,T3);7 };8 9template<class T1,class T2,class T3>10 double CeilDemo<T1,T2,T3>::ceil(T1 a,T2 b,T3 c){11 return a+b+c;12 }1314 #endifTemplateDemo03.cpp1 #include<iostream.h>2 #include "TemplateDemo03.h"3 4void main(){5 CeilDemo<double,double> cd;6 cout<<cd.ceil(2,3.1,4.1)<<endl;7 }编译错误：1 --------------------Configuration: TemplateDemo03 - Win32 Debug--------------------2 Compiling...3 TemplateDemo03.cpp4 g:\c++\cdaima\templatedemo03\templatedemo03.h(12) :5 error C2244: 'CeilDemo<T1,T2,T3>::ceil' : unable to resolve function overload6 g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) :7 error C2065: 'cd' : undeclared identifier8 g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) :9 error C2228: left of '.ceil' must have class/struct/union type10 Error executing cl.exe.1112 TemplateDemo03.obj - 3 error(s), 0 warning(s)从上面的例子我们可以看出，当我们试图把 T2 和 T3 定义为 double 类型就会出现错误（ T1 默认定义的是 int 类型）。那是不是我们按照作者所说把 T2 和 T3 也设定为默认值 double，是否还会出现错误？看下面的示例：类模板的默认模板类型形参示例 4：TemplateDemo03.h1 #ifndef TEMPLATE_DEMO_032 #define TEMPLATE_DEMO_033 4template<class T1=int,class T2=double,class T3=double> class CeilDemo{5 public:6 double ceil(T1,T2,T3);7 };8 9template<class T1,class T2,class T3>10 double CeilDemo<T1,T2,T3>::ceil(T1 a,T2 b,T3 c){11 return a+b+c;12 }1314 #endifTemplateDemo03.cpp1 #include<iostream.h>2 #include "TemplateDemo03.h"3 4void main(){5 CeilDemo<int,double,double> cd;6 cout<<cd.ceil(2,3.1,4.1)<<endl;7 }编译错误：--------------------Configuration: TemplateDemo03 - Win32 Debug--------------------Compiling...TemplateDemo03.cppg:\c++\cdaima\templatedemo03\templatedemo03.h(12) :error C2244: 'CeilDemo<T1,T2,T3>::ceil' : unable to resolve function overloadg:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) :error C2065: 'cd' : undeclared identifierg:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) :error C2228: left of '.ceil' must have class/struct/union typeError executing cl.exe.TemplateDemo03.obj - 3 error(s), 0 warning(s)从结果我们可以看出，和上例是一样的错误。从实例中我们可以总结如下：类模板如果有多个类型形参，如果使用类型形参默认值则尽量放在参数列表的末尾，而且默认的参数类型必须相同。如果从第一个形参设定了默认值之后的所有模板形参都要设定和第一个形参同类型的默认值。（声明：本人也是刚接触 C++，以上只是我经过实例演示对原作者提出的一些质疑，可能我的示例有不到之处，还望大神们不吝赐教，共同完善此博客，给像我一样的菜鸟提供一个学习的平台！）接下来验证“不能为函数模板的类型形参提供默认值”：类模板的默认模板类型形参示例 5：TemplateDemo04.cpp1 #include<iostream.h>2 3template<class T1,class T2,class T3>4 T1 sum(T1 a,T2 b,T3 c=int){5 return a+b+c;6 }7 8void main(){9 cout<<sum<double,double>(1.1,2.1,3)<<endl;10 }编译错误：1 --------------------Configuration: TemplateDemo04 - Win32 Debug--------------------2 Compiling...3 TemplateDemo04.cpp4 g:\c++\cdaima\templatedemo04\templatedemo04.cpp(4) :5 error C2062: type 'int' unexpected6 Error executing cl.exe.7 8TemplateDemo04.obj - 1 error(s), 0 warning(s)更改之后的 TemplateDemo.cpp1 #include<iostream.h>2 3template<class T1,class T2,class T3>4 T1 sum(T1 a,T2 b,T3 c){5 return a+b+c;6 }7 8void main(){9 cout<<sum<double,short,int>(1.1,3,257)<<endl;10 }运行结果： 261.1原作者演示实例如下：1 类模板非类型形参示例2 //模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在 main 函数中声明或定义一个模板。3 //类模板的定义4 template<class T>class A{public:T g(T a, T b); A();}; //定义带有一个类模板类型形参 T 的类A 5template<class T1,class T2>class B{public:void g();}; //定义带有两个类模板类型形参 T1， T2的类 B6 //定义类模板的默认类型形参，默认类型形参不适合于函数模板。7 template<class T1,class T2=int> class D{public: voidg();}; //定义带默认类型形参的类模板。这里把 T2 默认设置为 int 型。8 //template<class T1=int, class T2>class E{}; //错误，为 T1 设了默认类型形参则 T1 后面的所有形参都必须设置认默值。910 //以下为非类型形参的定义11 //非类型形参只能是整型，指针和引用，像 double， String, String **这样的类型是不允许的。但是 double &， double *对象的引用或指12 针是正确的。13 template<class T1,int a> class Ci{public:void g();}; //定义模板的非类型形参，形参为整型14 template<class T1,int &a>class Cip{public:void g();};15 template<class T1,A<int>* m> class Cc{public:void g();}; //定义模板的模板类型形参，形参为int 型的类 A 的对象的指针。16 template<class T1,double*a>class Cd{public:void g();}; //定义模板的非类型形参，形参为double 类型的引用。17 class E{}; template<class T1,E &m> class Ce{}; //非类型模板形参为对象的引用。18 //以下非类型形参的声明是错误的。19 //template<class T1,A m>class Cc{}; //错误，对象不能做为非类型形参，非类型模板形参的类型只能是对象的引用或指针。20 //template<class T1,double a>class Cc{}; //错误，非类型模板的形参不能是 double 类型，可以是 double 的引用。21 //template<class T1,A<int> m>class Cc{}; //错误，非类型模板的形参不能是对象，必须是对象的引用或指针。这条规则对于模板型参22 也不例外。23 //在类模板外部定义各种类成员的方法，24 //typeid(变量名).name()的作用是提取变量名的类型，如 int a，则 cout<<typeid(a).name()将输出 int25 template<class T> A<T>::A(){cout<<"class A goucao"<<typeid(T).name()<<endl;} //在类模板外部定义类的构造函数的方法26 template<class T> T A<T>::g(T a,T b){cout<<"class A g(T a,T b)"<<endl;} //在类模板外部定义类模板的成员27 template<class T1,class T2> voidB<T1,T2>::g(){cout<<"class gf()"<<typeid(T1).name()<<typeid(T2).name()<<endl;}28 //在类外面定义类的成员时 template 后面的模板形参应与要定义的类的模板形参一致29 template<class T1,int a> voidCi<T1,a>::g(){cout<<"class Cig()"<<typeid(T1).name()<<endl;}30 template<class T1,int &a> voidCip<T1,a>::g(){cout<<"class Cipg()"<<typeid(T1).name()<<endl;}31 //在类外部定义类的成员时， template 后的模板形参应与要定义的类的模板形参一致32 template<class T1,A<int> *m> voidCc<T1,m>::g(){cout<<"class Ccg()"<<typeid(T1).name()<<endl;}33 template<class T1,double* a> voidCd<T1,a>::g(){cout<<"class Cdg()"<<typeid(T1).name()<<endl;}3435 //带有默认类型形参的模板类，在类的外部定义成员的方法。36 //在类外部定义类的成员时， template 的形参表中默认值应省略37 template<class T1,class T2> voidD<T1,T2>::g(){cout<<"class D g()"<<endl;}38 //template<class T1,class T2=int> void D<T1,T2>::g(){cout<<"class D k()"<<endl;} //错误，在类模板外部定义带有默认类型的形39 参时，在 template 的形参表中默认值应省略。40 //定义一些全局变量。41 int e=2; doubleed=2.2; double*pe=&ed;42 A<int> mw; A<int> *pec=&mw; E me;4344 //main 函数开始45 int main()46 { // template<class T>void h(){} //错误，模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行。47 //A<2> m; //错误，对类模板不存在实参推演问题，类模板必须在尖括号中明确指出其类型。48 //类模板调用实例49 A<int> ma; //输出"class A goucao int"创建 int 型的类模板 A 的对象 ma。50 B<int,int> mb; mb.g(); //输出"class B g() int int"创建类模板 B 的对象 mb，并把类型形参 T1和 T2 设计为 int51 //非类型形参的调用52 //调用非类型模板形参的实参必须是一个常量表达式，即他必须能在编译时计算出结果。任何局部对象，局部变量，局部对象的地址，局部53 变量的地址都不是一个常量表达式，都不能用作非类型模板形参的实参。全局指针类型，全局变量，全局对象也不是一个常量表达式，不能54 用作非类型模板形参的实参。55 //全局变量的地址或引用，全局对象的地址或引用 const 类型变量是常量表达式，可以用作非类型模板形参的实参。56 //调用整型 int 型非类型形参的方法为名为 Ci，声明形式为 template<class T1,int a> classCi57 Ci<int,3>//正确，数值 R 是一个 int 型常量，输出"class Ci g() int"58 const int a2=3; Ci<int,a2> mci1; mci1.g(); //正确，因为 a2 在这里是 const 型的常量。输出"class Ci g() int"59 //Ci<int,a> mci; //错误， int 型变量 a 是局部变量，不是一个常量表达式。60 //Ci<int,e> mci; //错误，全局 int 型变量 e 也不是一个常量表达式。61 //调用 int&型非类型形参的方法类名为 Cip，声明形式为 template<class T1,int &a>class Cip62 Cip<int,e> mcip; //正确，对全局变量的引用或地址是常量表达式。63 //Cip<int,a> mcip1; //错误，局部变量的引用或地址不是常量表达式。64 //调用 double*类型的非类形形参类名为 Cd，声明形式为 template<class T1,double *a>classCd65 Cd<int,&ed> mcd; //正确，全局变量的引用或地址是常量表达式。66 //Cd<int,pe> mcd1; //错误，全局变量指针不是常量表达式。67 //double dd=3.3; //错误，局部变量的地址不是常量表达式，不能用作非类型形参的实参68 //Cd<int,&e> mcd; //错误，非类型形参虽允许一些转换，但这个转换不能实现。6970 //调用模板类型形参对象 A<int> *的方法类名为 Cc，声名形式为 template<class T1,A<int>*m> class Cc71 Cc<int,&mw> mcc; mcc.g(); //正确，全局对象的地址或者引用是常量表达式72 //Cc<int,&ma> mcc; //错误，局部变量的地址或引用不是常量表达式。73 //Cc<int,pec> mcc2; //错误，全局对象的指针不是常量表达式。7475 //调用非类型形参 E&对象的引用的方法类名为 Ce。声明形式为 template<class T1,E &m>class Ce76 E me1; //Ce<int,me1> mce1; //错误，局部对象不是常量表达式77 Ce<int,me> mce; //正确，全局对象的指针或引用是常量表达式。78 //非类型形参的转换示例，类名为 Ci79 //非类型形参允许从数组到指针，从函数到指针的转换， const 修饰符的转换，提升转换，整值转换，常规转换。80 const short s=3; Ci<int,s> mci4†//正确，虽然 short 型和 int 不完全匹配，但这里可以将 short型转换为