【C++从练气到飞升】08---模板

骑猪看日落 2024-04-22 04:11 67阅读 0赞

![b69c619d7f3544e9a958e6682bc0ab19.png][]

?**个人主页**：[库库的里昂][Link 1]  
✨**收录专栏**：[C++从练气到飞升][C]  
?**鸟欲高飞先振翅，人求上进先读书****。**

![266ea5a5363a43b5a383205fbb8308ea.jpeg][]

**目录**

一、泛型编程

什么是泛型编程:

二、函数模板

1. 函数模板概念

2. 函数模板格式

3. 函数模板的原理

4. 函数模板的实例化

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

2. 显式实例化:在函数名后的<>中指定模板参数的实际类型

5. 模板参数的匹配原则

三、类模板

1. 类模板的定义格式

2. 类模板的实例化

--------------------

> 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。[点击跳转到网站][Link 2]

### 一、泛型编程 ###

如果想要实现通用的函数进行交换，第一想到的就是直接学过的函数重载，如下述：当我们交换两个数值时，无论是整形、浮点型、还是字符型，使用Swap函数传参来交换，编译器会根据你所传入的数据类型，自动匹配对应的Swap函数进行交换

void Swap(int& left, int& right)
    {
     int temp = left;
     left = right;
     right = temp;
    }
    void Swap(double& left, double& right)
    {
     double temp = left;
     left = right;
     right = temp;
    }
    void Swap(char& left, char& right)
    {
     char temp = left;
     left = right;
     right = temp;
    }

但是使用**函数重载**虽然**可以实现**，但是有**以下几个不好的地方**：

*  重载的函数**仅仅是类型不同**，代码复用率比较低，只要有**新类型出现****时**，就**需要用户自己增加对应的函数**
 *  代码的可维**护性比较低**，一个出错可能所有的重载均出错

那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？  
如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件(即生成具体类型的代码）。

#### 什么是泛型编程: ####

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

### 二、函数模板 ###

#### 1. 函数模板概念 ####

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

#### 2. 函数模板格式 ####

template<typename T1, typename T2,......,typename Tn>
    返回值类型 函数名(参数列表){}

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

template<typename T>
    void Swap( T& left, T& right)
    {
     T temp = left;
     left = right;
     right = temp;
    }

#### 3. 函数模板的原理 ####

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

template<typename T>
    void Swap(T& left, T& right)
    {
    	T temp = left;
    	left = right;
    	right = temp;
    }
    int main()
    {
    	int i = 1, j = 2;
    	Swap(i, j);
    
    	double a = 1.1, b = 2.2;
    	Swap(a, b);
    
    	char n = 'a';
    	char m = 'b';
    	Swap(n, m);
    	return 0;
    }

![58b501b3d0004f14b3a13e339aa1f82b.png][]

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

![4f7e8913d9854c51bc5e36c6752d8180.png][]

实际中当需要交换两个数据的时候不需要自己写Swap函数，因为库中已经实现好了，可以用库中的swap（**注意：s小写**）实现对两个同类型数据的交换

![c3f0378620d743f18a65afdf497fb201.png][]

#### 4. 函数模板的实例化 ####

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

#### 1. 隐式实例化:让编译器根据实参推演模板参数的实际类型 ####

template<class T>
    T Add(const T& left, const T& right)
    {
    	return left + right;
    }
    int main()
    {
    	int a1 = 10, a2 = 20;
    	double d1 = 10.0, d2 = 20.0;
    	Add(a1, a2);//都是整型
    	Add(d1, d2);//都是浮点型
    	//Add(a1, d1);//该语句编译不通过
    	Add(a1, (int)d1);//强制类型转换，将两个参数设置成同类型
    	Add((double)a1, d1);//强制类型转换，将两个参数设置成同类型
    	return 0;
    }

该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错  
此时有两种处理方式：

*  用户自己来强制转化，对其中一个参数进行强制类型转换，使得两个参数是同类型数据
 *  在函数模板的参数列表中再增加一个模板参数template<class T1,class T2>
 *  使用显示实例化

**注意**：在模板中，编译器一般不会进行类型转换操作

#### 2. 显式实例化:在函数名后的<>中指定模板参数的实际类型 ####

template<class T>
    T Add(const T& left, const T& right)
    {
    	return left + right;
    }
    int main()
    {
    	int a1 = 1;
    	double b1 = 1.1;
    	//显式实例化
    	Add<int>(a1, b1);
    	Add<double>(a1, b1);
    	return 0;
    }

**如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。**

template<class T>
    T* func(int n)
    {
    	return new T[n];
    }
    int main()
    {
    	int* ptr = func<int>(10);
    	int* ptr = func(10);//错误写法
    	return 0;
    }

**如上述显式实例化的使用场景代码**，函数模板func并没有模板参数T类型的形参，而是int类型，因此编译器就无法去根据用户传递的实参类型去推导出模板参数T的具体类型。所以，调用func函数时，必须进行显式实例化。**显然编译器不会根据函数的返回值去推导模板参数T的类型**

#### 5. 模板参数的匹配原则 ####

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

// 专门处理int的加法函数
    int Add(int left, int right)
    {
     return left + right;
    }
    // 通用加法函数
    template<class T>
    T Add(T left, T right)
    {
     return left + right;
    }
    void Test()
    {
     Add(1, 2); // 与非模板函数匹配，编译器不需要特化
     Add<int>(1, 2); // 调用编译器特化的Add版本
    }

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

// 专门处理int的加法函数
    int Add(int left, int right)
    {
     return left + right;
    }
    // 通用加法函数
    template<class T1, class T2>
    T1 Add(T1 left, T2 right)
    {
     return left + right;
    }
    void Test()
    {
     Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
     Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
    }

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

### 三、类模板 ###

#### 1. 类模板的定义格式 ####

template<class T1, class T2, ..., class Tn>
    class 类模板名
    {
     // 类内成员定义
    };

// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
    template<class T>
    class Vector
    { 
    public :
     Vector(size_t capacity = 10)
     : _pData(new T[capacity])
     , _size(0)
     , _capacity(capacity)
     {}
     
     // 使用析构函数演示：在类中声明，在类外定义。
     ~Vector();
     
     void PushBack(const T& data);
     void PopBack();
     // ...
     
     size_t Size() {return _size;}
     
    private:
     T* _pData;
     size_t _size;
     size_t _capacity;
    };
    // 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
    template <class T>
    Vector<T>::~Vector()
    {
     if(_pData)
     delete[] _pData;
     _size = _capacity = 0;
    }

注意：Vector不是具体的类，编译器是会根据被实例化的类型生成具体类。类模板中的成员函数放在类外面进行定义时需要加模板参数（Vector::~Vector()）而非（Vector:: ~Vector()），因为单独的Vector已经不再表示类型了，Vector才表示一个具体的类型。  
**类模板中的成员函数，声明和定义不要分离到两个文件中**

#### 2. 类模板的实例化 ####

类模板实例化与[函数模板实例化][Link 3]不同，**类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类**

// Vector类名，Vector<int>才是类型
    Vector<int> s1;
    Vector<double> s2;

[b69c619d7f3544e9a958e6682bc0ab19.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/9214abeb172c4317a053f9129ccb20d9.png
[Link 1]: https://blog.csdn.net/m0_68662723
[C]: http://t.csdnimg.cn/eQPZG
[266ea5a5363a43b5a383205fbb8308ea.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/0aaceec02b49460388ab424b2ab299ba.jpeg
[Link 2]: https://www.captainbed.cn/wxz
[58b501b3d0004f14b3a13e339aa1f82b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/3148067048e945e8a4aa0d4d6ea0f4bd.png
[4f7e8913d9854c51bc5e36c6752d8180.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/8561c356575341cf9081f2966c2f85e1.png
[c3f0378620d743f18a65afdf497fb201.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/25f8998460304bc5b39c682acc2863f6.png
[Link 3]: https://so.csdn.net/so/search?q=%E5%87%BD%E6%95%B0%E6%A8%A1%E6%9D%BF%E5%AE%9E%E4%BE%8B%E5%8C%96&spm=1001.2101.3001.7020