C/C++ 深入浅出C++模板（上）

  不知道你是否思考过一个问题，那就是为什么C++有丰富的库，而C语言却没有？比如说C++有STL库，线程库等。其实一个很重要的因素就是因为C++引入了泛型编程这个概念，也就是我们熟悉的模板。今天我们就一起来深入理解什么是泛型编程，以及模板的概念，学完这些之后，我们就能够更好得理解C++这门语言。

                              连峰去天不盈尺 枯松倒挂倚绝壁,飞湍瀑流争喧豗。

提示：以下是本篇文章正文内容，下面案例可供参考

---

一、 泛型编程

1.1概念引入
  我们如何实现一个通用的逆序函数？

void Reverse(int* left, int* right)
{
    while (left < right)
    {
        int tmp = *left;
        *left = *right;
        *right = tmp;
        left++;
        right--;
    }
}
void Reverse(double* left, double* right)
{
    while (left < right)
    {
        double tmp = *left;
        *left = *right;
        *right = tmp;
        left++;
        right--;
    }
}
void Reverse(char* left, char* right)
{
    while (left < right)
    {
        char tmp = *left;
        *left = *right;
        *right = tmp;
        left++;
        right--;
    }
}
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
26
27
28
29
30
31
32
33

运用我们之前学习过的知识，我们知道使用函数重载虽然可以实现，但是有一下几个不好的地方：
1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增
加对应的函数
2. 代码的可维护性比较低，一个出错可能所有的重载均出错。

能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
其中，模板包括函数模板和类模板。

---

二、 函数模板

2.1概念

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

2.2函数模板格式

template
返回值类型 函数名(参数列表){}

实现一个通用的逆序函数。代码示例：

template
void Reverse(T* left, T* right)
{
    while (left < right)
    {
        T tmp = *left;
        *left = *right;
        *right = tmp;
        left++;
        right--;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

---

2.3函数模板的原理

**函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。
**

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

---

2.4函数模板的实例化
概念：用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

1. 隐式实例化：让编译器根据实参推演模板参数的实际类型
   代码示例：

template
void Reverse(T* left, T* right)
{
    while (left < right)
    {
        T tmp = *left;
        *left = *right;
        *right = tmp;
        left++;
        right--;
    }
}
int main()
{
    int a[100] = { 0 };
    char b[100];
    double c[100] = { 0.0 };
    for (int i = 1; i <= 10; i++)
    {
        a[i] = i;
        b[i] = 'i';
        c[i] = (double)i;
    }

    Reverse(a, a + 10);//这里就是隐式实例化
    Reverse(b, b + 10);
    Reverse(c, c + 10);
    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
26
27
28
29

模板参数 – 很多用法和函数参数是很像的
模板参数 – 传递的是类型
函数参数 – 传递的对象值
2. 显式实例化：在函数名后的<>中指定模板参数的实际类型
代码示例：

#include
using namespace std;
template
T* func(int n)
{
       return new T[n];
}
int main()
{
       //函数模板显示实例化
       int* p = func(10);//加一个显式实例化
       double* p2 = func(10);
       char* p3 = func(10);
       return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.5 模板参数的匹配原则

1.一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。
2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板。
3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

函数定义和声明分离的情况
代码示例：

//声明
template
void Swap(T& left, T& right);
//定义
template
void Swap(T& left, T& right)
{
       T tem = left;
       left = right;
       right = tem;
}
1
2
3
4
5
6
7
8
9
10
11

注意：模板不支持声明和定义放到两个文件中。声明和定义分离在两个文件就会出现链接失败

---

三、类模板

3.1 类模板的定义格式

template
class 类模板名
{
// 类内成员定义
};    
1
2
3
4
5

3.2 类模板的实例化
概念：类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

template
class vector
{
public:
	//初始化列表
	vector(size_t capacity = 10);
private:
	t* _pdata;//数组
	size_t _size;
	size_t _capacity;
};
int main()
{
    // Vector类名，Vector才是类型
    Vector v1;
    Vector v2;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

---

四、非类型模板参数

概念：
模板参数分类类型形参与非类型形参。
类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

代码示例： 定义一个模板类型的静态数组

template
class array
{
public:
	T& operator[](size_t index) { return _array[index]; }
	const T& operator[](size_t index)const { return _array[index]; }
	size_t size()const { return _size; }
	bool empty()const { return 0 == _size; }
private:
	T _array[N];
	size_t _size;
};
1
2
3
4
5
6
7
8
9
10
11
12

注意：
1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
2. 非类型的模板参数必须在编译期就能确认结果。

总结和思维导图

总结

  本文总共写了四个要点，分别是泛型编程，函数模板，类模板和非类型模板参数，通过一些代码来揭示这些要点之间的关系。模板不可否认的是C++的一个重要学习内容，希望大家学完之后能有所收获！模板（下）我们主要讲模板的偏特化等知识。下期再见哦。