一.泛型编程

引入

我们之前都写过交换函数Swap，例如这样的：

1. //交换两个整型
2. void Swap(int*x1, int *x2)
3. {
4.  int tmp = *x1;
5.  *x1 = *x2;
6.  *x2 = tmp;
7. 
8. }

如果要交换其它的类型该怎么办呢？

那只能当个CV工程师了，然后再修修改改，但是如果有很多类型呢？后期又需要改动该怎么办呢？一个一个函数的改吗？多个功能相同的函数，又会使程序可读性降低，代码冗余。

我们能用一个具有交换函数逻辑的模具，来实现不同需求吗？

答案是可以，用模板就可以了。

模板

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础

语法：template<class/typename  参数，class/typename  参数 .......>

注意：class 或是  typename  是用来定义模板参数的关键字，不可以使用  struct，并且可             以定义多个模板参数。

模板分为两种：

1.函数模板

 2.类模板

注意：类模板和模板类不是同一个概念（详见下文）

示例：Swap模板

1. template<typename T>   //这个模板的作用域是下面的一个大括号，当然也可以有多个模板参数
2. void Swap(T& x1, T& x2)  //注意这里要用引用
3. {
4.  T tmp = x1;
5.  x1 = x2;
6.  x2 = tmp;
7. }

二.函数模板

概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

编译器由模板生成函数的过程称为实例化。

上文中的Swap模板就是一个函数模板。

隐式实例化

隐式实例化是指编译器根据实参自己推演参数的类型，并生成对应的函数；

以Swap函数模板为例：

1. template<typename T>
2. void Swap(T &x1, T &x2)
3. {
4.  T tmp = x1;
5.  x1 = x2;
6.  x2 = tmp;
7. }
8. 
9. int main()
10. {
11.   int a1 = 1, a2 = 2;
12.   double b1= 5.2, b2 = 6.4;
13.   char c1 = 'a', c2 = 'e';
14.   Swap(a1, a2); cout << a1 << " " << a2 << endl;
15.   Swap(b1, b2); cout << b1 << " " << b2 << endl;
16.   Swap(c1, c2); cout << c1 << " " << c2 << endl;
17. 
18.   return 0;
19. 
20. }

即使它们用的是同一个模板，但他们调用的并不是同一个函数，从汇编中就可以看出来：

显式实例化

语法：函数名<类型>（实参1，实参2.....）

例：

1. template<typename T>
2. void Swap(T &x1, T &x2)
3. {
4.  T tmp = x1;
5.  x1 = x2;
6.  x2 = tmp;
7. }
8. 
9. int main()
10. {
11.   int a1 = 1, a2 = 2;
12.   double b1= 5.2, b2 = 6.4;
13.   char c1 = 'a', c2 = 'e';
14.   Swap<int>(a1, a2);   //显式实例化
15.   return 0;
16. 
17. }

其实有的时候我们不得不显示实例化模板：

 

模板参数的匹配原则

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数；

例：

1. // 专门处理int的加法函数
2. int Add(int left, int right)
3. {
4. return left + right;
5. }
6. // 通用加法函数
7. template<class T>
8. T Add(T left, T right)
9. {
10. return left + right;
11. }
12. void Test()
13. {
14. Add(1, 2); // 与非模板函数匹配，编译器不需要特化
15. Add<int>(1, 2); // 调用编译器特化的Add版本
16. }

2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函         数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么         将选择模板

如下动图所示：

 

3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

三.类模板

定义格式

1. template<class T1, class T2, ..., class Tn>  //typename也可以
2. class 类模板名
3. {
4. // 类内成员定义
5. };

类模板的实例化

类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，也就是要显式实例化；

注意：类模板名字不是真正的类，而实例化的结果才是真正的类

例：

1. // Stack是类名，Stack<int>才是类型
2. Stack<int> s1;
3. Stack<double> s2;

类模板和模板类的区别

类模板

类模板是指定义一个通用的类模板，其中包含一个或多个类型参数，这些类型参数可以在实例化时被替换为具体的类型。

例：

1. template <typename T>
2. class MyContainer
3. {
4. public:
5. void add(T element);
6. T get(int index);
7. private:
8.     T elements[100];
9. int size;
10. };

在这个例子中：

1，`MyContainer` 是一个类模板；

2，`T` 是一个类型参数，可以在实例化时被替换为具体的类型，例如 `int` 或 `double`。

模板类

模板类是指使用类模板生成的具体类。

例：

1. //.....
2. MyContainer<int> intContainer;
3. MyContainer<double> doubleContainer;
4. //.....

在这个例子中:

1，`MyContainer<int>` 和 `MyContainer<double>` 都是模板类；

2，它们是使用类模板 `MyContainer` 生成的具体类，分别用于存储 `int` 和 `double` 类型的        元素。

🐬🤖本篇文章到此就结束了， 若有错误或是建议的话，欢迎小伙伴们指出；🕊️👻

😄😆希望小伙伴们能支持支持博主啊，你们的支持对我很重要哦；🥰🤩

😍😁谢谢你的阅读。😸😼