【C++】第七节—模版初阶+STL简介

admin管理员组

文章数量:1442327

【C++】第七节—模版初阶+STL简介

【Reference - C++ Reference】C++网站，查阅资料

一、模版初阶

1. 泛型编程

如何实现一个通用的交换函数呢？

代码语言：javascript代码运行次数：0运行复制

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;
}
//......

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

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

如果在C++中，也能够存在这样一个 模具，通过给这个模具中 填充不同材料 ( 类型 )，来 获得不同 材料的铸件 ( 即生成具体类型的代码），那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。

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

模版分为 函数模版和 类模版。

2. 函数模版

2.1 函数模板概念

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

2.2 函数模板格式

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

代码语言：javascript代码运行次数：0运行复制

//函数模版
//泛型编程
template<typename T>//T是类型的名称
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

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

2.3 函数模板的原理

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

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

【注意】

这里生成的函数虽然公用的是同一个模版，但是在真正调用的时候是调用不同的函数，是调用根据 传入的实参类型来推演生成对应 类型的函数（编译器来当牛马，来生成对应的函数），可以看下面的反汇编代码

编译时编译器根据使用的情况用函数模版生成对应的函数，编译成对应的指令里面指的就是生成的对应的函数。

代码语言：javascript代码运行次数：0运行复制

//函数模版
//泛型编程
template<typename T>//T是类型的名称
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

//如果两个实参类型不同，我们也可以像这样去定义下面的函数模版
//但是这里面会存在精度丢失的问题
//是根据函数模版出来的函数之间构成重载
//编译器会根据传过来的参数类型生成对应的函数，并不是所有类型的函数都生成
//模版参数和函数参数定义方法很相似
template<class T1,class T2>//T是类型的名称，类型
void Swap(T1& left, T2& right)  //对象
{
	T temp = left;
	left = right;
	right = temp;
}

int main()
{
	int x = 1, y = 10;
	double  m = 1.1, n = 10.8;

	Swap(x, y);
	Swap(m, n);
	Swap(x, m);

	return 0;
}

2.4 函数模板的实例化

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

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

代码语言：javascript代码运行次数：0运行复制

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);
	/*
	该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
	通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，
	编译器无法确定此处到底该将T确定为int 或者 double类型而报错
	注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
    Add(a1, d1);
    */
// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
	Add(a, (int)d);(强制类型转换)

	return 0;
}

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

代码语言：javascript代码运行次数：0运行复制

int main(void)
{
	int a = 10;
	double b = 20.0;
	// 显式实例化
	Add<int>(a, b);//此时函数模版里面的类型T就直接是int类型，就是显示定义T

	return 0;
}

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

在什么场景下我们一定要使用显示实例化呢？见下：

代码语言：javascript代码运行次数：0运行复制

template<class T>
T* Func(size_t n)//编译器无法根据传的实参来推导T的类型
{
    return new T[n];
}

int main(void)
{
	int a = 10;
	double b = 20.0;
	// 显式实例化
	Add<int>(a, b);//此时函数模版里面的类型T就直接是int类型，就是显示定义T

    //上面函数形参里面没有T，我们就不能根据实参类型来推导对应的T，所以这里就需要用到显示实例化
    Func<int>(10);//注意这个显示实例化的格式
    Func<int>(20);    

	return 0;
}

2.5 模板参数的匹配原则

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板 还可以被实例化 为这 个非模板函数 会优先调用现成的函数，有现成的就用现成的。

代码语言：javascript代码运行次数：0运行复制

int main(void)
{
	int a = 10;
	double b = 20.0;
	// 显式实例化
	Add<int>(a, b);
	return 0;
}

// 专门处理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版本
}

但是，当两个函数不一样的时候会显示用谁呢？看下面的场景

代码语言：javascript代码运行次数：0运行复制

int main(void)
{
	int a = 10;
	double b = 20.0;
	// 显式实例化
	Add<int>(a, b);
	return 0;
}

// 专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
	return left + right*5;
}
void Test()
{
	Add(1, 2); // 与非模板函数匹配，编译器不需要特化，就算函数不一样，仍然会调用原本就有的函数而不是使用根据模版生成的函数
	Add<int>(1, 2); //显示实例化就必须用函数模版，调用编译器推演生成的Add版本
    Add(1.1, 2.2); //此时是调用根据模版生成的对应的形参类型的函数
}

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

代码语言：javascript代码运行次数：0运行复制

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

看下面的场景，我们可以调试看看到底是如何调用的

代码语言：javascript代码运行次数：0运行复制

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

template<class T>
T Add(T& left,T& right)
{
    return (left+right)*5;
}

template<class T1,class,T2>
T Add(T1& left,T2& right)
{
    return (left+right)*10;
}

int main()
{
    cout<<Add(1,12)<<endl;//优先调用同一个类型的T的模版函数，第1个

    cout<<Add<int>(1,12)<<endl;//显示实例化调用第2个，这里原生的函数和模本生成的函数不会构成重定义，编译器生成的函数名会跟原生的函数名不一样，这样就不会冲突了

    cout<<Add(1.1,12.2)<<endl;//这里的类型相同，优先调用第2个

    cout<<Add(1.1,12)<<endl;//实参类型不同，只能调用第3个

    return 0;
}

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

3. 类模板

3.1 类模板的定义格式

代码语言：javascript代码运行次数：0运行复制

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

代码语言：javascript代码运行次数：0运行复制

//在某些情况下，下面可以进行平替
typedef int STDataType;
using STDataType = int;

代码语言：javascript代码运行次数：0运行复制

#include<iostream>
using namespace std;
// 类模版
template<typename T>
class Stack
{
public:
	Stack(size_t capacity = 4)
	{
		_array = new T[capacity];
		_capacity = capacity;
		_size = 0;
	}
	void Push(const T& data);
private:
	T* _array;
	size_t _capacity;
	size_t _size;
};
// 模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误，具体原因后面会讲
//在同一个文件里面，声明和定义分离要这样写
template<class T>
//并且这里类名不是类型，要带上模版参数<T>
void Stack<T>::Push(const T& data)
{
	// 扩容
	_array[_size] = data;
	++_size;
}
int main()
{
    //我们前面数据结构里面可以修改栈里面存放的数据的类型，为什么栈还需要模版呢？
    //如果我们定义一个队列，队列里面有两个栈，一个存放int类型的数据，
    //一个存放double类型的数据，此时我们用以前的方法就不能行了，一种栈只能存放一种类型的数据，
    //此时在这种场景下我们就可以使用类模版
    //用类型来定义对象，Stack是类名，Stack<int>才是类型，看看下面
	Stack<int> st1; // int
	Stack<double> st2; // double

	return 0;
}

3.2 类模板的实例化

类模版必须显示实例化，st1和st2是两个不同类型的类

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

代码语言：javascript代码运行次数：0运行复制

// Stack是类名，Stack<int>才是类型，注意，这里跟我们以前（类名就是类型）不一样了
Stack<int> st1; // int
Stack<double> st2; // double

---

二、STL简介

1. 什么是STL

STL(standard template libaray-标准模板库)： 是 C++标准库 的重要组成部分，不仅是一个可复用的组件库，而且 是一个包罗 数据结构与算 法的软件框架。

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)采用，可移植性好，可公开、修改甚至贩卖，从命名风格和编程 风格上看，阅读性非常高。 我们后面学习 STL 要阅读部分源代码，主要参考的就是这个版本。

3. STL的六大组件

4. STL的重要性

1. 在笔试中

把二叉树打印成多行_牛客题霸_牛客网

重建二叉树_牛客题霸_牛客网

用两个栈实现队列_牛客题霸_牛客网

2. 在面试中

3. 在工作中

网上有句话说：“不懂STL，不要说你会C++”。STL是C++中的优秀作品，有了它的陪伴，许多底层的数据结构以及算法都不需要自己重新造轮子，站在前人的肩膀上，健步如飞的快速开发。

5. 如何学习STL

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

完——

下节课我们学习重头戏——string

本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。 原始发表：2025-04-02，如有侵权请联系 cloudcommunity@tencent 删除前往查看stl编译器函数c++int

本文标签： C第七节模版初阶STL简介