c++ 模板教程（c语言中文网） 自己运行实例
注：本文的例子全部都是c语言中文网上的c++教程，自己只不过是运行了一遍而已。个别地方添加了点东西。
17.1模板函数教程
1.自己的第一个运行的程序（c语言中文网上源代码）
// ConsoleApplication1.cpp : 定义控制台应用程序的入口点。 //#include "stdafx.h" #include <string> #include <iostream> using namespace std; template<typename T> void swap(T * p1, T *p2) {T temp = *p1;*p1 = *p2;*p2 = temp; }int main() {int n1 = 100, n2 = 29;swap(&n1, &n2);cout << n1 <<" "<< n2 << endl;char c1 = 'm', c2 = 'n';swap(c1,c2);cout << c1 << " " << c2 << endl;double d1 = 1.23, d2 = 2.34;swap(d1,d2);cout << d1 << " " << d2 << endl;return 0; }运行结果：
下面我们来总结一下定义模板函数的语法：
template <typename 类型参数1 , typename 类型参数2 , ...> 返回值类型 函数名(形参列表){
//在函数体中可以使用类型参数
}
类型参数可以有多个，它们之间以逗号,分隔。类型参数列表以< >包围，形式参数列表以( )包围。
typename关键字也可以使用class关键字替代，它们没有任何区别。C++ 早期对模板的支持并不严谨，没有引入新的关键字，而是用 class 来指明类型参数，但是 class 关键字本来已经用在类的定义中了，这样做显得不太友好，所以后来 C++ 又引入了一个新的关键字 typename，专门用来定义类型参数。不过至今仍然有很多代码在使用 class 关键字，包括 C++ 标准库、一些开源程序等。
为了加深模板的理解，下面再看一个例子：
// 求三个数的最大的.cpp : 定义控制台应用程序的入口点。 #include "stdafx.h" #include <string> #include <iostream> #include <memory> using namespace std;//模板的声明和普通函数声明也是类似的（我自己理解是：模板函数体去掉，剩下的就是声明了。） template <typename T> T max(T &, T &, T &);int _tmain(int argc, _TCHAR* argv[]) {int a = 12, b = 189, c = 2002;auto re = max(a,b,c);cout << re << endl;return 0; }template <typename T> T max(T &a, T &b, T &c) {T temp;temp = (a > b ? a : b);temp = (temp > c ? temp : c);return temp; } 函数模板也可以提前声明，不过声明时需要带上模板头，并且模板头和函数定义（声明）是一个不可分割的整体，它们可以换行，但中间不能有分号。7.2 类模板教程
C++ 除了支持函数模板，还支持类模板（Class Template）。函数模板中定义的类型参数可以用在函数声明和函数定义中，类模板中定义的类型参数可以用在类声明和类实现中。类模板的目的同样是将数据的类型参数化。
声明类模板的语法为：
template<typename 类型参数1 , typename 类型参数2 , …> class 类名{
//TODO:
};
类模板和函数模板都是以 template 开头（当然也可以使用 class，目前来讲它们没有任何区别），后跟类型参数；类型参数不能为空，多个类型参数用逗号隔开。
一但声明了类模板，就可以将类型参数用于类的成员函数和成员变量了。换句话说，原来使用 int、float、char 等内置类型的地方，都可以用类型参数来代替。
假如我们现在要定义一个类来表示坐标，要求坐标的数据类型可以是整数、小数和字符串，例如：
- x = 10、y = 10
- x = 12.88、y = 129.65
- x = "东经180度"、y = "北纬210度"
这个时候就可以使用类模板，请看下面的代码：
// 第一个例子.cpp : 定义控制台应用程序的入口点。 //#include "stdafx.h" #include <string> #include <iostream> using namespace std;template <typename T1,typename T2> class Point { public:Point(const T1 & t1, const T2 &t2) :m_x(t1), m_y(t2){} public:T1 getX()const; //获取x坐标void setX(T1 x); //设置x坐标T2 getY()const; //获取y坐标void setY(T2 y);//设置y坐标private:T1 m_x;T2 m_y; };int _tmain(int argc, _TCHAR* argv[]) { Point<int, int> p1(10,20);Point<int, float> p2(10,12.5);Point<float, char*> p3(12.5,"东经180度");Point<int,int>* p4 = new Point<int, int>(10, 20);Point<int,double>* p5 = new Point<int, double>(10,15.123);cout << p1.getX() << endl;cout << p1.getY() << endl;cout << p2.getX() << endl;cout << p2.getY() << endl;cout << p3.getX() << endl;cout << p3.getY() << endl;cout << p4->getX() << endl;cout << p4->getY() << endl;cout << p5->getX() << endl;cout << p5->getY() << endl;return 0; }x 坐标和 y 坐标的数据类型不确定，借助类模板可以将数据类型参数化，这样就不必定义多个类了。
注意：模板头和类头是一个整体，可以换行，但是中间不能有分号。上面的代码仅仅是类的声明，我们还需要在类外定义成员函数。在类外定义成员函数时仍然需要带上模板头，格式为：
template<typename 类型参数1 , typename 类型参数2 , …>
返回值类型 类名<类型参数1 , 类型参数2, ...>::函数名(形参列表){
//TODO:
}
第一行是模板头，第二行是函数头，它们可以合并到一行，不过为了让代码格式更加清晰，一般是将它们分成两行。
下面就对 Point 类的成员函数进行定义：
使用类模板创建对象
上面的两段代码完成了类的定义，接下来就可以使用该类创建对象了。使用类模板创建对象时，需要指明具体的数据类型。请看下面的代码：
与函数模板不同的是
类模板在实例化时必须显式地指明数据类型，编译器不能根据给定的数据推演出数据类型。
注意：类外定义的成员函数首先要加模板头，接着要在类名后面的尖括号内添加具体的参数类型。
所以类内定义的成员函数和类外定义的成员函数是有区别的。
除了对象变量，我们也可以使用对象指针的方式来实例化：
需要注意的是，赋值号两边都要指明具体的数据类型，且要保持一致。下面的写法是错误的：
7.3 C++函数模板的重载
注意标准库也有一个函数叫swap,所以有时候调用会和标准库的swap冲突，这时候就需要加作用域运算符。
#include <string> #include <iostream> #include <memory> using namespace std;template <typename T,unsigned LEN> void swap(T a[LEN],T b[LEN]) { for (int i = 0; i !=LEN; ++ i){T temp = a[i];a[i] = b[i];b[i] = temp; } }template<typename T> void swap(T a[],T b[],int len) { for(int i = 0;i != len; ++i){T temp = a[i];a[i] = b[i];b[i] = temp; }}template <typename T> void swap(T & a ,T & b) {T temp = a;a = b;b = temp;cout << "call void swap(T &,T &)." << endl; }int main() { int a[6] = {1,2,3,4,5,6}; int b[] = {11,22,33,44,55,66}; swap(a,b); for(int i = 0;i != sizeof(a) / sizeof(a[0]); ++ i)cout << a[i] << endl;int x = 1.1,y = 1234.2; ::swap(x,y); //这里加::,为了调用全局作用域定义的swap，加了全局作用域运算符:: cout << x << y << endl; int l = sizeof(a) / sizeof(a[0]); swap(a,b,l); for(int i = 0;i != l ;++ i){cout << a[i] << endl;}return 0; }在第二个函数模板中，最后一个参数的类型为具体类型（int），而不是泛型。并不是所有的模板参数都必须被泛型化。
7.6 C++模板的显式具体化
C++ 没有办法限制类型参数的范围，我们可以使用任意一种类型来实例化模板。但是模板中的语句（函数体或者类体）不一定就能适应所有的类型，可能会有个别的类型没有意义，或者会导致语法错误。
例如有下面的函数模板，它用来获取两个变量中较大的一个：
请读者注意a > b这条语句，>能够用来比较 int、float、char 等基本类型数据的大小，但是却不能用来比较结构体变量、对象以及数组的大小，因为我们并没有针对结构体、类和数组重载>。
另外，该函数模板虽然可以用于指针，但比较的是地址大小，而不是指针指向的数据，所以也没有现实的意义。
除了>，+-*/==<等运算符也只能用于基本类型，不能用于结构体、类、数组等复杂类型。总之，编写的函数模板很可能无法处理某些类型，我们必须对这些类型进行单独处理。
模板是一种泛型技术，它能接受的类型是宽泛的、没有限制的，并且对这些类型使用的算法都是一样的（函数体或类体一样）。但是现在我们希望改变这种“游戏规则”，让模板能够针对某种具体的类型使用不同的算法（函数体或类体不同），这在 C++ 中是可以做到的，这种技术称为模板的显示具体化（Explicit Specialization）。
函数模板和类模板都可以显示具体化，下面我们先讲解函数模板的显示具体化，再讲解类模板的显示具体化。
函数模板的显式具体化
定义：让模板能够针对某种具体的类型使用不同的算法（函数体或类体不同），这在 C++ 中是可以做到的，这种技术称为模板的显示具体化（Explicit Specialization）。
在讲解函数模板的显示具体化语法之前，我们先来看一个显示具体化的例子：
#include <string> #include <iostream> using namespace std;typedef struct{string name;int age;float score; }STU;//function template template<class T> const T& Max(const T& a,const T & b); //function explicit specialization:具体方法是把模板参数列表中的参数清空，然后后面的 //1.函数用显式具体化，也就是函数名称后面加<>里面放具体的类型， //2.再者就是函数参数列表中也用具体的类型 template<> const STU& Max<STU>(const STU& a,const STU &b); //overload ostream & operator<<(ostream &,const STU &);int main() { STU s1 = {"liming",12,92.2},s2 = {"wanglin",16,100}; cout << Max(s1,s2) << endl;return 0; }template<class T> const T & Max(const T & a,const T & b) {return a > b ? a : b; } template<> const STU& Max<STU>(const STU & a,const STU & b) {return a.score > b.score ? a : b; } ostream & operator<< (ostream &out,const STU & stu) { out << stu.name << " , " << stu.age << " , " << stu.score;return out; }运行结果：
wanglin , 16 , 100 本例中，STU 结构体用来表示一名学生(Student)，它有三个成员，分别是姓名(name)、年龄(age)、成绩(score)；Max() 函数用来获取两份数据中较大的一份。
要想获取两份数据中较大的一份，必然会涉及到对两份数据的比较。对于 int、float、char 等基本类型的数据，直接比较它们本身的值即可，而对于 STU 类型的数据，直接比较它们本身的值不但会有语法错误，而且毫无意义，这就要求我们设计一套不同的比较方案，从语法和逻辑上都能行得通，所以本例中我们比较的是两名学生的成绩（score）。
不同的比较方案最终导致了算法（函数体）的不同，我们不得不借助模板的显示具体化技术对 STU 类型进行单独处理。第 14 行代码就是显示具体化的声明，第 34 行代码进行了定义。
请读者注意第 34 行代码，Max<STU>中的STU表明了要将类型参数 T 具体化为 STU 类型，原来使用 T 的位置都应该使用 STU 替换，包括返回值类型、形参类型、局部变量的类型。
Max 只有一个类型参数 T，并且已经被具体化为 STU 了，这样整个模板就不再有类型参数了，类型参数列表也就为空了，所以模板头应该写作template<>。
另外，Max<STU>中的STU是可选的，因为函数的形参已经表明，这是 STU 类型的一个具体化，编译器能够逆推出 T 的具体类型。简写后的函数声明为：
也就是说，函数模板显式具体化有2个步骤：
1.将函数名后面加<>，里面按照模板参数列表逐个实例化类型参数,模板参数列表置空，因为不需要推断类型了，有了具体的实例化类型后。
2.将函数中返回类型（函数参数列表，以及局部变量中）的T类型变量都实例化成STU
3.函数名后面的尖括号和里面的实例化类型可以省略。
类模板的显式具体化
除了函数模板，类模板也可以显示具体化，并且它们的语法是类似的。
为什么类模板参数具体化呢？有时候，可能需要在为特殊类型实例化时，对模板进行修改，使其行为不同。在这种情况下，可以创建显示具体化。当具体化模板和通用模板都与实例化请求匹配时，编译器将选择具体化版本。
具体化类模板定义格式为：template<>class 类名<具体类型>
注意：在上面的显式具体化例子中，我们为所有的类型参数都提供了实参，所以最后的模板头为空，也即template<>。另外 C++ 还允许只为一部分类型参数提供实参，这称为部分显式具体化。
部分显式具体化只能用于类模板，不能用于函数模板。
仍然以 Point 为例，假设我现在希望“只要横坐标 x 是字符串类型”就以|来分隔输出结果，而不管纵坐标 y 是什么类型，这种要求就可以使用部分显式具体化技术来满足。请看下面的代码：
具体化是将通用模板具体化，因此必须要有通用模板存在才可以使用具体化，否则单独使用会报错。下面先来一个具体的例子：
运行结果：
template<> template<class T1,class T2> 在《C++类模板》一节中我们定义了一个 Point 类，用来输出不同类型的坐标。在输出结果中，横坐标 x 和纵坐标 y 是以逗号,为分隔的，但是由于个人审美的不同，我希望当 x 和 y 都是字符串时以|为分隔，是数字或者其中一个是数字时才以逗号,为分隔。为了满足我这种奇葩的要求，可以使用显示具体化技术对字符串类型的坐标做特殊处理。
下面的例子演示了如何对 Point 类进行显示具体化：
类模板也可以部分参数具体实例化，如下即是：
#include <string> #include <iostream> using namespace std;template<typename T1,typename T2> class AA{public:void print(); };template<typename T1,typename T2> void AA<T1,T2>::print() {cout << "template<class T1,class T2>" << endl; }template<class T1> class AA<T1,int> {public:void print(); };template<class T1> void AA<T1,int>::print() {cout << "template<class T1,int>" << endl; }int main() { AA<double,int> p1; p1.print(); AA<double,double> p2; p2.print(); AA<int,int> p3; p3.print();return 0; }也可以如下定义：
#include <string> #include <iostream> using namespace std;template<typename T1,typename T2> class AA{public:void print(); };template<typename T1,typename T2> void AA<T1,T2>::print() {cout << "template<class T1,class T2>" << endl; }template<class T2> //部分实例化的时候，当类名后面放<>以及内部的2个参数的时候，必须按照原来的类的顺序放置。 class AA<int,T2> {public:void print(); };template<class T2> void AA<int,T2>::print() {cout << "template<class int,T2>" << endl; }int main() { AA<double,int> p1; p1.print(); AA<double,double> p2; p2.print(); AA<int,int> p3; p3.print();return 0; }注意：在部分具体实例化的类的定义中：
1.模板头中仅仅只放类型参数（类型未知的参数）。
2.类名后面的尖括号内放所有参数，包括类型已知的和未知的。
类名后面之所以要列出所有的类型参数，是为了让编译器确认“到底是第几个类型参数被具体化了”，如果写作template<typename T2> class Point<char*>，编译器就不知道char*代表的是第一个类型参数，还是第二个类型参数。
题外话：如果编译函数的时候g++ 遇到类似下面的结果,...
undefined reference to some_function...，那一般的错误就是没有给函数提供定义。这就是一个连接期的错误，有的读者可能说：我提供定义了呀，那么就该检查下自己定义的函数和声明的函数是不是同一个(一般是参数类型或者返回类型出现错误)。
r@r:~/coml/c++/review$ g++ 4.cc -o 123 /usr/bin/ld: /tmp/ccIzfftp.o: in function `main': 4.cc:(.text+0x83): undefined reference to `void Swap<int*>(int*, int*, int)' collect2: error: ld returned 1 exit status7.7 c++模板中的非类型参数
模板是一种泛型技术，目的是将数据的类型参数化，以增强 C++ 语言（强类型语言）的灵活性。C++ 对模板的支持非常自由，模板中除了可以包含类型参数，还可以包含非类型参数，例如：
template<typename T, int N> class Demo{ }; template<class T, int N> void func(T (&arr)[N]);T 是一个类型参数，它通过class或typename关键字指定。N 是一个非类型参数，用来传递数据的值，而不是类型，它和普通函数的形参一样，都需要指明具体的类型。类型参数和非类型参数都可以用在函数体或者类体中。
当调用一个函数模板或者通过一个类模板创建对象时，非类型参数会被用户提供的、或者编译器推断出的值所取代。
在函数模板中使用非类型参数
在《C++函数模板的重载》一节中，我们通过 Swap() 函数来交换两个数组的值，其原型为：
template<typename T> void Swap(T a[], T b[], int len);
形参 len 用来指明要交换的数组的长度，调用 Swap() 函数之前必须先通过sizeof求得数组长度再传递给它。(除非用数组的引用传递数组名字，就不用转换成指针了)
有读者可能会疑惑，为什么在函数内部不能求得数组长度，一定要通过形参把数组长度传递进去呢？这是因为数组在作为函数参数时会自动转换为数组指针，而sizeof只能通过数组名求得数组长度，不能通过数组指针求得数组长度，这在《数组和指针绝不等价，数组是另外一种类型》《数组到底在什么时候会转换为指针》两节中已经作了详细讲解。
运行结果：
111 222 123 6 6 too big:exception:too big index. 0 106 2067.9将C++模板应用于多文件编程
在将函数应用于多文件编程时，我们通常是将函数定义放在源文件（.cpp文件）中，将函数声明放在头文件（.h文件）中，使用函数时引入（#include命令）对应的头文件即可。
编译是针对单个源文件的，只要有函数声明，编译器就能知道函数调用是否正确；而将函数调用和函数定义对应起来的过程，可以延迟到链接时期。正是有了链接器的存在，函数声明和函数定义的分离才得以实现。
将类应用于多文件编程也是类似的道理，我们可以将类的声明和类的实现分别放到头文件和源文件中。类的声明已经包含了所有成员变量的定义和所有成员函数的声明（也可以是 inline 形式的定义），这样就知道如何创建对象了，也知道如何调用成员函数了，只是还不能将函数调用与函数实现对应起来，但是这又有什么关系呢，反正链接器可以帮助我们完成这项工作。
总起来说，不管是函数还是类，声明和定义（实现）的分离其实是一回事，都是将函数定义放到其他文件中，最终要解决的问题也只有一个，就是把函数调用和函数定义对应起来（找到函数定义的地址，并填充到函数调用处），而保证完成这项工作的就是链接器。
基于传统的编程思维，初学者往往也会将模板（函数模板和类模板）的声明和定义分散到不同的文件中，以期达到「模块化编程」的目的。但事实证明这种做法是不对的，程序员惯用的做法是将模板的声明和定义都放到头文件中。
模板并不是真正的函数或类，它仅仅是用来生成函数或类的一张“图纸”，在这个生成过程中有三点需要明确：
- 模板的实例化是按需进行的，用到哪个类型就生成针对哪个类型的函数或类，不会提前生成过多的代码；
- 模板的实例化是由编译器完成的，而不是由链接器完成的；
- 在实例化过程中需要知道模板的所有细节，包含声明和定义。
-
将函数模板的声明和定义分散到不同的文件
为了更加深入地说明问题，现在有一个反面教材，它将函数模板的声明和实现分别放到了头文件和源文件。
func.cpp 源码： - //交换两个数的值template<typename T> void Swap(T &a, T &b){T temp = a;a = b;b = temp;}//冒泡排序算法void bubble_sort(int arr[], int n){for(int i=0; i<n-1; i++){bool isSorted = true;for(int j=0; j<n-1-i; j++){if(arr[j] > arr[j+1]){isSorted = false;Swap(arr[j], arr[j+1]); //调用Swap()函数}}if(isSorted) break;}} //func.h源码#ifndef _FUNC_H#define _FUNC_Htemplate<typename T> void Swap(T &a, T &b);void bubble_sort(int arr[], int n);#endif //main.cpp源码#include <iostream>#include "func.h"using namespace std;int main(){int n1 = 10, n2 = 20;Swap(n1, n2);double f1 = 23.8, f2 = 92.6;Swap(f1, f2);return 0;}
该工程包含了两个源文件和一个头文件，func.cpp中定义了两个函数，func.h中对函数进行了声明，main.cpp中对函数进行了调用，这是典型的将函数的声明和实现分离的编程模式。
运行上面的程序，会产生一个链接错误，意思是无法找到void Swap<double>(double &, double &)这个函数。主函数 main() 中共调用了两个版本的 Swap() 函数，它们的原型分别是：void Swap<double>(int &, int &);
为什么针对 int 的版本能够找到定义，而针对 double 的版本就找不到呢？
void Swap<double>(double &, double &);
我们先来说针对 double 的版本为什么找不到定义。当编译器编译main.cpp时，发现使用到了 double 版本的 Swap() 函数，于是尝试生成一个 double 版本的实例，但是由于只有声明没有定义，所以生成失败。不过这个时候编译器不会报错，而是对该函数的调用做一个记录，希望等到链接程序时在其他目标文件（.obj 文件或 .o 文件）中找到该函数的定义。很明显，本例需要到func.obj中寻找。但是遗憾的是，func.cpp中没有调用 double 版本的 Swap() 函数，编译器不会生成 double 版本的实例，所以链接器最终也找不到 double 版本的函数定义，只能抛出一个链接错误，让程序员修改代码。
那么，针对 int 的版本为什么能够找到定义呢？请读者注意bubble_sort()函数，该函数用来对数组元素进行排序，在排序过程中需要频繁的交换两个元素的值，所以调用了 Swap() 函数，这样做的结果是：编译生成的func.obj中会有一个 int 版本的 Swap() 函数定义。编译器在编译main.cpp时虽然找不到 int 版本的实例，但是等到链接程序时，链接器在func.obj中找到了，所以针对 int 版本的调用就不会出错。将类模板的声明和实现分散到不同的文件
我们再看一个类模板的反面教材，它将类模板的声明和实现分别放到了头文件和源文件
-
point.h 源码：
- #ifndef _POINT_H#define _POINT_Htemplate<class T1, class T2>class Point{public:Point(T1 x, T2 y): m_x(x), m_y(y){ }public:T1 getX() const{ return m_x; }void setX(T1 x){ m_x = x; }T2 getY() const{ return m_y; };void setY(T2 y){ m_y = y; };void display() const;private:T1 m_x;T2 m_y;};#endif //point.cpp源码#include <iostream>#include "point.h"using namespace std;template<class T1, class T2>void Point<T1, T2>::display() const{cout<<"x="<<m_x<<", y="<<m_y<<endl;} //main.cpp#include <iostream>#include "point.h"using namespace std;int main(){Point<int, int> p1(10, 20);p1.setX(40);p1.setY(50);cout<<"x="<<p1.getX()<<", y="<<p1.getY()<<endl;Point<char*, char*> p2("东京180度", "北纬210度");p2.display();return 0;}
该工程包含了两个源文件和一个头文件，point.h中声明了类模板，point.cpp中对类模板进行了实现，main.cpp中通过类模板创建了对象，并调用了成员函数，这是典型的将类的声明和实现分离的编程模式。
运行上面的程序，会产生一个链接错误，意思是无法通过 p2 调用Point<char*, char*>::display() const这个函数。
类模板声明位于point.h中，它包含了所有成员变量的定义以及构造函数、get 函数、set 函数的定义，这些信息足够创建出一个完整的对象了，并且可以通过对象调用 get 函数和 set 函数，所以main.cpp的前 11 行代码都不会报错。而第 12 行代码调用了 display() 函数，该函数的定义位于point.cpp文件中，并且point.cpp中也没有生成对应的实例，所以会在链接期间抛出错误。总结
通过上面的两个反面教材可以总结出，「不能将模板的声明和定义分散到多个文件中」的根本原因是：模板的实例化是由编译器完成的，而不是由链接器完成的，这可能会导致在链接期间找不到对应的实例。
修复上面两个项目的方法也很简单，就是将 func.cpp、point.cpp 的模板定义（实现）部分分别合并到 func.h、point.h 中。 -
7.10 C++模板的显式实例化
前面讲到的模板的实例化是在调用函数或者创建对象时由编译器自动完成的，不需要程序员引导，因此称为隐式实例化。相对应的，我们也可以通过代码明确地告诉编译器需要针对哪个类型进行实例化，这称为显式实例化。
编译器在实例化的过程中需要知道模板的所有细节：对于函数模板，也就是函数定义；对于类模板，需要同时知道类声明和类定义。我们必须将显式实例化的代码放在包含了模板定义的源文件中，而不是仅仅包含了模板声明的头文件中。
显式实例化的一个好处是，可以将模板的声明和定义（实现）分散到不同的文件中了。
函数模板的显式实例化
以上节讲到的 compare() 函数为例，针对 double 类型的显式实例化代码为：
template void Swap(double &a, double &b); 这条语言由两部分组成，前边是一个template关键字（后面不带<>），后面是一个普通的函数原型，组合在一起的意思是：将模板实例化成和函数原型对应的一个具体版本。
将该代码放到 func.cpp 文件的最后，再运行程序就不会出错了。
另外，还可以在包含了函数调用的源文件（main.cpp）中再增加下面的一条语句：
extern template void Swap(double &a, double &b);
该语句在前面增加了extern关键字，它的作用是明确地告诉编译器，该版本的函数实例在其他文件中，请在链接期间查找。不过这条语句是多余的，即使不写，编译器发现当前文件中没有对应的模板定义，也会自动去其他文件中查找。
上节我们展示了一个反面教材，告诉大家不能把函数模板的声明和定义分散到不同的文件中，但是现在有了显式实例化，这一点就可以做到了，下面就对上节的代码进行修复。
func.cpp 源码：
文件func.h
#ifndef _FUNC_H#define _FUNC_Htemplate<typename T> void Swap(T &a, T &b);void bubble_sort(int arr[], int n);#endif //main.cpp源码 #include <iostream>#include "func.h"using namespace std;//显示实例化声明（也可以不写）extern template void Swap(double &a, double &b);extern template void Swap(int &a, int &b);int main(){int n1 = 10, n2 = 20;Swap(n1, n2);double f1 = 23.8, f2 = 92.6;Swap(f1, f2);return 0;}显式实例化也包括声明和定义，定义要放在模板定义（实现）所在的源文件，声明要放在模板声明所在的头文件（当然也可以不写）。既然声明放在模板声明所在文件，那不是应该放在func.h中吗？
类模板的显式实例化
类模板的显式实例化和函数模板类似。以上节的 Point 类为例，针对char*类型的显式实例化（定义形式）代码为：
template class Point<char*, char*>;相应地，它的声明形式为：
extern template class Point<char*, char*>;不管是声明还是定义，都要带上class关键字，以表明这是针对类模板的。
另外需要注意的是，显式实例化一个类模板时，会一次性实例化该类的所有成员，包括成员变量和成员函数。
有了类模板的显式实例化，就可以将类模板的声明和定义分散到不同的文件中了，下面我们就来修复上节的代码。
point.cpp 源文件：
point.cpp的源码
#ifndef _POINT_H#define _POINT_Htemplate<class T1, class T2>class Point{public:Point(T1 x, T2 y): m_x(x), m_y(y){ }public:T1 getX() const{ return m_x; }void setX(T1 x){ m_x = x; }T2 getY() const{ return m_y; };void setY(T2 y){ m_y = y; };void display() const;private:T1 m_x;T2 m_y;};#endifmain.cpp source code
#include <iostream>#include "point.h"using namespace std;//显式实例化声明（也可以不写）extern template class Point<char*, char*>;extern template class Point<int, int>;int main(){Point<int, int> p1(10, 20);p1.setX(40);p1.setY(50);cout<<"x="<<p1.getX()<<", y="<<p1.getY()<<endl;Point<char*, char*> p2("东京180度", "北纬210度");p2.display();return 0;}函数模板和类模板的实例化语法是类似的，我们不妨对它们做一下总结：
extern template declaration; //实例化声明 template declaration; //实例化定义对于函数模板来说，declaration 就是一个函数原型；对于类模板来说，declaration 就是一个类声明。
显式实例化的缺陷
C++ 支持显式实例化的目的是为「模块化编程」提供一种解决方案，这种方案虽然有效，但是也有明显的缺陷：程序员必须要在模板的定义文件（实现文件，也就是.cpp文件而非.h文件）中对所有使用到的类型进行实例化。这就意味着，每次更改了模板使用文件（调用函数模板的文件，或者通过类模板创建对象的文件），也要相应地更改模板定义文件，以增加对新类型的实例化，或者删除无用类型的实例化。
一个模板可能会在多个文件中使用到，要保持这些文件的同步更新是非常困难的。而对于库的开发者来说，他不能提前假设用户会使用哪些类型，所以根本就无法使用显式实例化，只能将模板的声明和定义（实现）全部放到头文件中；C++ 标准库几乎都是用模板来实现的，这些模板的代码也都位于头文件中。
总起来说，如果我们开发的模板只有我们自己使用，那也可以勉强使用显式实例化；如果希望让其他人使用（例如库、组件等），那只能将模板的声明和定义都放到头文件中了。
总结
以上是生活随笔为你收集整理的c++ 模板教程（c语言中文网） 自己运行实例的全部内容，希望文章能够帮你解决所遇到的问题。
- 上一篇： MySQL中变量的定义和变量的赋值使用（
- 下一篇： 【C++】字符串中运算符的重载问题