C++的初阶模板和STL
回顾之前的内存管理，我们还要补充一个概念：内存池
也就是定位new会用到的场景，内存池只会去开辟空间。
申请内存也就是去找堆，一个程序中会有很多地方要去找堆，这样子效率会很低下，为了提高程序运行的效率，我们需要建立内存池，多去储存一些内存。
第二种理解方式：因为距离太远了，所需要的成本太高了，需要建立内存池。
这里再来打个比方，堆相当于妈妈，掌管着财政，家里有你，爸爸，弟弟，妹妹，以前你还没有上大学，用到钱的地方不多，可以直接问妈妈要钱，但是随着你上了大学，发现喝水吃饭洗澡没有一个地方不需要用钱，于是向妈妈要钱的次数变多了，爸爸有工作，需要用钱的地方不多，弟弟妹妹需求也不是很大。所以妈妈直接给了你一笔生活费，从那里面去取着用，这就相当于内存池
内存管理我们需要注意两个点：
1.不要忘记释放
2.不要错配
不要忘记释放好理解的，我们学过malloc和free都懂，动态开辟内存空间，需要程序员手动释放空间；
不要错配来看一个例子：
#include<iostream>
using namespace std;class A
{
public:A(int a = 0): _a(a){cout << "A():" << this << endl;}~A(){cout << "~A():" << this << endl;delete _p;}
private:int _a;int* _p = new int;
};int main()
{
// /*A* p2 = (A*)operator new(sizeof(A));
// new(p2)A(10);
//
// p2->~A();
// operator delete(p2);*/
//
// // 1、不要忘记释放
// // 2、不要交错使用
// //
// //A* p1 = (A*)operator new(sizeof(A));
// //delete p1;
//
// /*A* p1 = new A;
// delete p1;*/
//
}
不要用new ,delect的时候，想着用malloc,free混着用
模板初阶
我们先来看一段代码：
如何实现一个通用的交换函数呢？
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语言，函数名必须不同，C++支持函数的重载，函数名可以相同，支持参数不同的，但是上面这三个函数逻辑结构类似，有什么办法简化呢？
答案是模板
模板像做月饼的模子一样，可以工业化生产。
使用函数重载虽然可以实现，但是有一下几个不好的地方：
- 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增 加对应的函数
- 代码的可维护性比较低，一个出错可能所有的重载均出错泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
函数模板
函数模板概念
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生 函数的特定类型版本。
函数模板格式
template<typename T1, typename T2,…,typename Tn>
返回值类型 函数名(参数列表){}
template<typename T>
void Swap( T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替 class)
实现例子如下：
#include <iostream>
using namespace std;
template<class T>
void Swap(T& left, T& right)//注意要大写，否则会跟库里面的函数冲突
{T temp = left;left = right;right = temp;
}
int main()
{int x = 0;int y = 8;Swap(x, y);double m = 1.0;double n = 2.0;Swap(m, n);
}
函数模板的原理
函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。 所以其实模板就是将本来应该我们做的重复的事情交给了编译器
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应 类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演， 将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。
其实模板也就是让编译器去当牛马，函数模板类似于函数的调用
template<class T1, class T2> // 类型
void Swap(T1& left, T2& right) // 对象
函数模板的实例化
用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化 和显式实例化。
-
隐式实例化：让编译器根据实参推演模板参数的实际类型
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; }需要注意的是打印结果会有所出入：
测试代码：
template<class T> T Add(const T& left, const T& right) {return left + right; } int main() {//int x = 0;//int y = 8;//Swap(x, y);//double m = 1.0;//double n = 2.0;//Swap(m, n);int a1 = 10;int a2 = 20;double a3 = 10.1;double a4 = 20.2;cout << Add(a1, (int)a3) << endl;cout << Add((double)a1, a3) << endl;}
- 显式实例化：在函数名后的<>中指定模板参数的实际类型
int main(void)
{
int a = 10;
double b = 20.0;
// 显式实例化
Add<int>(a, b);
return 0;
}
显示实例化的应用场景：
template <class T>T*Func(size_t n)
{return new T[n];
}
Func<int>(10);
//这里形参没有带模板参数，需要显示实例化，因为没有办法推导
如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。
模板参数的匹配原则
- 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这 个非模板函数
// 专门处理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版本
}
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函数
}- 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
类模板
类模板的定义格式
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};拿栈来举例：
#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>
void Stack<T>::Push(const T& data)
{
// 扩容
_array[_size] = data;
++_size;
}
int main()
{
// 实例化生成对应的类，这里是两个不同的类型
Stack<int> st1; // int
Stack<double> st2; // double
return 0;
}
类模板的实例化
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的 类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。
// Stack是类名，Stack<int>才是类型
Stack<int> st1; // int
Stack<double> st2; // double
string类
为什么学习string类？
C语言中的字符串
C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列 的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户 自己管理，稍不留神可能还会越界访问。
标准库中的string类
string类(了解)
在使用string类时，必须包含#include头文件以及using namespace std;
string类的常用接口说明（注意下面我只讲解最常用的接口）
- string类对象的常见构造
调试代码如下：
int main()
{string s1;string s2("1111122222");string s3("1111111111", 3);//拷贝前3个数据string s4(100, 'x');string s5(s2, 4, 3);//从第四个开始打印三个数string s6(s2, 4);//没有限制，到字符串结尾string s7(s2, 4, 20);//超过长度，依旧是拷贝到字符串结尾cout << s1 << endl;cout << s2 << endl;cout << s3 << endl;cout << s4 << endl;cout << s5 << endl;cout << s6 << endl;cout << s7 << endl;
}
打印结果：
小小补充：
string的访问
代码：
class string
{
public:char& operator[] (size_t pos){assert(pos < _size);return _str[pos];}
private:char* _str;size_t _size;size_t _capacity;
};
int main()
{
//s2.operator[](0) = 'x';s2[0] = 'x';s2[5] = 'x';cout << s2 << endl;for (size_t i = 0; i < s2.size(); i++){s2[i]++;}cout << s2 << endl;//s2[30];return 0;
}
重载的底层在于断言，这有效防止越界的问题
访问可以做到像数组一样的改变，主要是因为引用，一般的传值返回是传的是拷贝
代码：
class string
{
public:char& operator[] (size_t pos){assert(pos < _size);return _str[pos];}
private:char* _str;size_t _size;size_t _capacity;
};
int main()
{
//s2.operator[](0) = 'x';s2[0] = 'x';s2[5] = 'x';cout << s2 << endl;for (size_t i = 0; i < s2.size(); i++){s2[i]++;}cout << s2 << endl;//s2[30];return 0;
}
重载的底层在于断言，这有效防止越界的问题
访问可以做到像数组一样的改变，主要是因为引用，一般的传值返回是传的是拷贝
模板的学习一定要借助文档，看之前先猜测一下，然后和底下的英文注释做对比
![[2025]基于微信小程序慢性呼吸系统疾病的健康管理(源码+文档+解答）](https://i-blog.csdnimg.cn/direct/a0087e55af2c410caf5fe1d1c809308e.png)
