【hello C++】模板初阶

目录

1. 泛型编程

2. 函数模板

2.1 函数模板的概念

2.2 函数模板格式

2.3 函数模板的原理

2.4 函数模板的实例化

2.5 模板参数的匹配原则

3. 类模板

3.1 类模板的定义格式

3.2 类模板的实例化

4. STL简介

4.1 什么是STL

4.2 STL的版本

4.3 STL的六大组件

4.4  STL的重要性

4.5 如何学习STL

4.6 STL的缺陷

---

 C++🌷

1. 泛型编程

下面请看一段代码：

#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
using namespace std;

//整形数据交换
void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
//浮点型数据的交换
void Swap(float& x, float& y)
{
	float tmp = x;
	x = y;
	y = tmp;
}
//字符型数据
void Swap(char& x, char& y)
{
	char tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a1 = 1, b1 = 2;
	Swap(a1, b1);
	float a2 = 1.2, b2 = 2.2;
	Swap(a2, b2);
	char a3 = 'x', b3 = 'y';
	Swap(a3, b3);
	cout << "a1:" << a1 << '\t' << "b1:" << b1 << endl;
	cout << "a2:" << a2 << '\t' << "b2:" << b2 << endl;
	cout << "a3:" << a3 << '\t' << "b3:" << b3 << endl;
	return 0;
}

在上述代码中使用函数重载，写了整型、浮点型、字符型的交换函数，完成了3组不同类型的数据

交换功能。

但看看代码，我们很容易发现它有以下几个不好的地方：

1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己

增加对应的函数；

2. 代码的可维护性比较低，一个出错可能所有的重载均出错

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

就如同上述的果冻膜具一样，我们往里面放什么佐料，做出来就是什么口味的果冻。

在C++中，也存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的

铸件(即生成具体类型的代码），这种编码方式便称为泛型编程。

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

模板又分为：函数模板和类模板。

2. 函数模板

2.1 函数模板的概念

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

产生函数的特定类型版本。

2.2 函数模板格式

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

typename是用来定义模板参数关键字，也可以使用class；

typename 后面的T1是随便取的，一般是大写字母或者单词首字母大写；

T1代表是一个模板类型（虚拟类型）

了解了上述格式，我们利用函数模板来将上述交换代码进行一个优化：

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;

//函数模板
template<typename T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a1 = 1, b1 = 2;
	Swap(a1, b1);
	float a2 = 1.2, b2 = 3.2;
	Swap(a2, b2);
	char a3 = 'x', b3 = 'y';
	Swap(a3, b3);
	cout << "a1:" << a1 << '\t' << "b1:" << b1 << endl;
	cout << "a2:" << a2 << '\t' << "b2:" << b2 << endl;
	cout << "a3:" << a3 << '\t' << "b3:" << b3 << endl;
	return 0;
}

我们发现确实利用一个模板达到了三组不同类型数据的交换。

那模板到底是怎么起作用的呢？它们调用的都是一个函数吗？那我们看下面：

2.3 函数模板的原理

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模

具。所以其实模 板就是将本来应该我们做的重复的事情交给了编译器

下面给个图更好的对上述语句进行一个直观的解释：

我们发现模板只是一个模板，不是真正的函数。

在编译器编译阶段 ，对于模板函数的使用， 编译器需要根据传入的实参类型来推演生成对应

类型的 函数 以供调用。

比如：当用 double 类型使用函数模板时，编译器通过对实参类型的推演，将 T 确定为 double

类 型，然 后产生一份专门处理 double 类型的代码 ，对于字符类型、整型也是如此。

2.4 函数模板的实例化

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

例化和显式实例 化 。

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

该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型

通过实参  a1  将  T  推演为  int  ，通过实参 a2  将  T  推演为  float  类型，但模板参数列表中只有

一个 T ，编译器无法确定此处到底该将 T  确定为  int 或者 double  类型而报错

注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要

背黑锅

对于上述问题，我们通常有以下两种解决方案：

1. 用户自己来强制转换；

 2. 重新弄一个模板；

3. 使用显示实例化：在函数名后的<>中指定模板参数的实际类型；

2.5 模板参数的匹配原则

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

这个非模板函数

// 专门处理int的加法函数
int Add(int left, int right)
{
    returnleft+right;
}

// 通用加法函数
template<class T>
T Add(T left, T right)
{
    return left+right;
}

void Test()
{
    Add(1, 2);       // 与非模板函数匹配，编译器不需要特化
    Add<int>(1, 2);  // 调用编译器特化的Add版本
}

2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数

而不会从该模板产生出一个实例。

如果模板可以产生一个具有更好匹配的函数，那么将选择模板

// 专门处理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函数
}

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

3. 类模板

3.1 类模板的定义格式

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

为什么会用到类模板定义呢？

在之前学习顺序表、链表...的时候我们通常使用 typedef DataType int 来声明结构里面存的数

据类型，我们想往里面存什么数据就将数据类型重定义不就好了，何必多此一举呢？

其实不然，typedef重定义确实可以达到上述效果，但如果我们想要定义两个链表，每个链表

里面存储不同类型的数据，那是不是就得把上述链表代码写两遍呢？

使用类模板便很好的解决这一问题，我们只要写一份代码，存不同类型数据的时候，编译器

便会自动推演生成存储对应数据类型的类

// 动态顺序表
// 注意：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;}

    T& operator[](size_t pos)
    {
        assert(pos<_size);
        return _pData[pos];
    }
private:
    T* _pData;
    size_t _size;
    size_t _capacity;
};


// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template<class T>
Vector<T>::~Vector()
{
    if(_pData)
        delete[] _pData;
    _size = _capacity = 0;
}

我们在使用类模板的时候，不能将类模板的声明和定义放在两个文件中。

如果将类模板声明和定义分开写的话也要写在同一文件中，像上述代码析构函数那种形式。 

3.2 类模板的实例化

类模板实例化与函数模板实例化不同， 类模板实例化需要在类模板名字后跟 <> ，然后将实例

化的类型放在 <> 中即可，类模板名字不是真正的类，而实例化的结果才是真正的类 。

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

4. STL简介

4.1 什么是STL

STL(standard template libaray- 标准模板库 ) ： 是 C++ 标准库的重要组成部分 ，不仅是一个可

复用的组件库，而且 是一个包罗数据结构与算法的软件框架 。

4.2 STL的版本

原始版本

Alexander Stepanov 、 Meng Lee 在惠普实验室完成的原始版本，本着开源精神，他们声明

允许任何人任意 运用、拷贝、修改、传播、商业使用这些代码，无需付费。唯一的条件就是

也需要向原始版本一样做开源使 用。 HP 版本 -- 所有 STL 实现版本的始祖。

P. J. 版本

由 P. J. Plauger 开发，继承自 HP 版本，被 Windows Visual C++ 采用，不能公开或修改，缺

陷：可读性比较低，符号命名比较怪异。

RW 版本

由 Rouge Wage 公司开发，继承自 HP 版本，被 C+ + Builder 采用，不能公开或修改，可读性

一般。

SGI 版本

由 Silicon Graphics Computer Systems ， Inc 公司开发，继承自 HP 版 本。被 GCC(Linux) 采用，可移植性好， 可公开、修改甚至贩卖，从命名风格和编程 风格上看，阅读性非常高。

4.3 STL的六大组件

4.4  STL的重要性

网上有句话说： “ 不懂 STL ，不要说你会 C++” 。 STL 是 C++ 中的优秀作品，有了它的陪伴，许

多底层的数据结构 以及算法都不需要自己重新造轮子，站在前人的肩膀上，健步如飞的快速

开发。

4.5 如何学习STL

 简单总结一下：学习STL的三个境界：能用，明理，能扩展 。

4.6 STL的缺陷

1. STL 库的更新太慢了。这个得严重吐槽，上一版靠谱是 C++98 ，中间的 C++03 基本一些修

订。 C++11 出 来已经相隔了13 年， STL 才进一步更新。

2. STL 现在都没有支持线程安全。并发环境下需要我们自己加锁。且锁的粒度是比较大的。

3. STL 极度的追求效率，导致内部比较复杂。比如类型萃取，迭代器萃取。

4. STL 的使用会有代码膨胀的问题，比如使用 vector/vector/vector 这样会生成多份代码，当

然这是模板语法本身导致的。

坚持打卡！😃