C++模板使用（学习总结）

用C写程序时，经常会遇到这样的场景：交换两个数，而我们会用一个Swap封装交换的函数，但随着进行交换的数据类型不同，需要封装的函数也要随着改变。

void Swap(int& left, int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}
1
2
3
4
5
6

上面的Swap只能交换int类型的数据，要交换double类型数据就需要重新封装一个函数，这样的编程效率显然是不高的，C++为解决这一痛点，引入了模板，提出了泛型编程的概念。

模板的使用

template<class T>
template<typename T>
1
2

template是模板的关键词，尖括号中是模板的名字，至于class和typename，两个没有区别，跟在这两个后面的叫做模板的名字，一般都用T做模板名，但想使用什么样的模板名没有规定，按照个人喜好。

函数模板

函数模板并不是一个函数，它是一个模子，刻画着函数的逻辑，比如上面的Swap就能被刻画成函数模板

template<class T>
void Swap(T& left, T& right)
{
	T tmp = left;
	left = right;
	right = tmp;
}
int main()
{
	int num1 = 1;
	int num2 = 2;

	Swap(num1, num2);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

如果要交换的数据类型是int，编译器在编译时会根据该数据类型生成一个函数，编译后模板中的T在函数中会被替换成int，如果数据类型是double，T会被替换成double。

使用模板函数有时要指定模板类型，比如

template<class T>

// 该模板返回一个地址，地址指向开辟的n个T类型的空间
T* f(int n)
{
	T* p = new T[n];
	return p;
}

int main()
{
	f<char>(1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

此时的函数模板的形参中没有T，上面的交换函数模板中的形参有T，调用函数时编译器会根据你传的参数去推导T的类型，去生成该类型的模板（这种实例化模板方式称为隐式实例化）。但形参中没有T，编译器无法推导T的类型，此时需要指定T的类型才能使用函数模板（这种实例化方式叫显式实例化），具体的使用是在函数名后加上尖括号，括号里是模板的参数类型，比如希望开辟n个char的空间，就在尖括号中写char。

缺省模板参数

template<class T = char>

// 该模板返回一个地址，开辟n个T类型的空间
T* f(int n)
{
	T* p = new T[n];
	return p;
}

int main()
{
	f(3);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

如果不想显式使用函数模板，就可以给模板参数加上缺省值，不指定类型使用时，就会以缺省值实例化模板。比如T的缺省值是char，这时f(3)，就是开辟3个char大小的空间。

非模板函数与函数模板同时存在

template<class T>
// 交换函数的通用模板
void Swap(T& left, T& right)
{
	T tmp = left;
	left = right;
	right = tmp;
}

// 只能交换int类型的交换函数
void Swap(int& left, int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}

int main()
{
	int num1 = 1;
	int num2 = 2;

	Swap(num1, num2);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

首先，这不是两个函数，更不构成函数重载，一个是模板，一个是函数。当两者同时存在，且函数是模板的一个实例化时，调用Swap会优先调用函数，当函数形参与调用的实参不一致时，才会去实例化模板。

比如上面有一个Swap函数，但只能交换int类型的数据，当用Swap交换num1和num2两个数时，由于两者都是int类型，所以编译器只会调用函数，不会实例化函数模板。当num1和num2的类型是char时，Swap函数不满足交换两个char类型的功能，因此编译器会去实例化模板函数。

总结就是，编译器不会做多余的工作，交换的数据类型是int，已经有了交换int的函数，何必自找麻烦去实例化一个函数，所以此时只会调用函数。当函数不能满足交换的需求时，才会去实例化模板。

类模板

template<class T>

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_data = new T[capacity];
		_capacity = capacity;
		_top = 0;
	}

private:
	T* _data;
	int _top;
	int _capacity;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

假设我需要定义一个Stack类，里面有一个存储数据的数组。有时需要存储的数据类型是int，有时会是double，有时既需要存储int又需要存储double的数据，存储的数据类型是不固定的，针对这样的情况，C++引入了类模板，这时Stack类中的数组类型就能用模板参数T替换。

int main()
{
	Stack<int> st;// 使用类模板实例化类时，需要在类名后加上要实例化的类型
	Stack<int>* ps = new Stack<int>;
	return 0;
}
1
2
3
4
5
6

对于模板类来说，只能显式地实例化类。

注意：一个模板参数只能使用一次

要再定义一个类模板，需要再定义一个模板参数

模板的声明与定义分离

与函数不同，模板在声明时，需要定义模板参数，定义时还需要定义模板参数

只要用到模板参数，就需要写模板参数的定义。但这样的分离还是有错的
链接错误，说明符号表找不到函数的地址。原因：在程序预处理后template.h展开在template.cpp和test.cpp两个源文件中，test.cpp调用了template.cpp中定义的函数，但头文件在test.cpp前面展开，虽然程序找不到要调用的函数，但找到了对应的模板，将模板实例化后就能得到对应的函数，所以这里不报错。

但template.cpp中定义的是模板，无论是函数模板还是类模板（类模板中包含函数模板），都不知道要用什么类型实例化模板，所以无法实例化成函数，在最后生成的符号表中就没有对应的地址。链接时test.cpp中有call指令，但对应函数的地址是空的，需要在符号表中查找，但无法找到，因此链接错误。

要解决这个错误，需要在cpp文件中显式实例化模板

template是语法要求，显式实例化时需要加上。但在源文件中显式实例化的方式还是有点繁琐，通常在定义模板时，会将声明和定义放在一个hpp文件中，相当于把原来在test.cpp中定义模板的代码剪切到了一个hpp头文件中，当程序预处理之后，hpp会在test.cpp中展开。