目录
泛型编程
对于两个数的交换，以我们之前学的知识，我们会写出下面的代码：
// 交换两个整型
void Swapi(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
// 交换两个双精度浮点型
void Swapd(double* p1, double* p2)
{
double tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
因为C语言不支持函数重载，所以用于交换不同类型变量的函数的函数名是不能相同的，并且传参形式必须是址传递，不能是值传递。
在学习了C++的函数重载和引用后，我们又会用如下方法实现两个数的交换：
// 交换两个整型
void Swap(int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
}
// 交换两个双精度浮点型
void Swap(double& x, double& y)
{
double tmp = x;
x = y;
y = tmp;
}
C++的函数重载使得用于交换不同类型变量的函数可以拥有相同的函数名，并且传参使用引用传参，使得代码看起来不那么晦涩难懂。
使用函数重载虽然可以实现，但是有一下几个不好的地方：
1、重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数。
2、代码的可维护性比较低，一个出错可能所有的重载均出错。
那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？
想象一下，你负责设计一条可以生产各种型号和颜色塑料板凳的自动化生产线。这条生产线不仅要能高效地生产标准尺寸的板凳，还要能够灵活调整，以满足客户对不同尺寸、颜色的需求。C++模板正是这样一种机制，它允许你创建可适应多种类型的通用代码框架。
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
函数模板
函数模板的概念
概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
函数模板的格式
格式：
template <typename T>
return_type function_name(T arg1, T arg2, ..., T argN)
{
// 函数体
}实例：
template<typename T>
template<class T> // 二选一
void Swap(T& x, T& y)
{
T tmp = x;
x = y;
y = tmp;
}
注意：typename是用来定义模板参数的关键字，也可以用class代替，但是不能用struct代替。
函数模板的原理
那么函数模板的底层原理是什么呢？大家都知道，瓦特改良蒸汽机，人类开始了工业革命，解放了生产力。机器生产淘汰掉了很多手工产品。其本质就是将重复的工作交给了机器去完成。有人给出了论调：懒人创造世界！
懒不是傻懒，如果你想少干，就要想出懒的方法。要懒出风格，懒出境界。
函数模板是一个蓝图，它本身并不是函数。是编译器产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。
在编译器编译阶段，对于函数模板的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如，当用int类型使用函数模板时，编译器通过对实参类型的推演，将T确定为int类型，然后产生一份专门处理int类型的代码，对于double类型也是如此。
函数模板的实例化
用不同类型的参数使用模板时，称为模板的实例化。
模板实例化分为隐式实例化和显示实例化。
1、隐式实例化：让编译器根据实参推演模板参数的实际类型
#include <iostream>
using namespace std;
template<typename T>
T Add(const T& x, const T& y)
{
return x + y;
}
int main()
{
int a = 10, b = 20;
int c = Add(a, b); //编译器根据实参a和b推演出模板参数为int类型
return 0;
}
注意：使用模板时，编译器一般不会进行类型转换操作。所以，以下代码将不能通过编译：
int a = 10;
double b = 1.1;
int c = Add(a, b);
因为在编译期间，编译器根据实参推演模板参数的实际类型时，根据实参a将T推演为int，根据实参b将T推演为double，但是模板参数列表中只有一个T，编译器无法确定此处应该将T确定为int还是double。
此时，我们有两种处理方式，第一种就是我们在传参时将b强制转换为int类型，第二种就是使用下面说到的显示实例化。
2、显示实例化：在函数名后的<>中指定模板参数的实际类型
#include <iostream>
using namespace std;
template<typename T>
T Add(const T& x, const T& y)
{
return x + y;
}
int main()
{
int a = 10;
double b = 1.1;
int c = Add<int>(a, b); //指定模板参数的实际类型为int
return 0;
}
在显式实例化中，尖括号< >紧跟在函数名之后，里面填写希望实例化的模板参数类型。这种方式给了程序员更多的控制权，特别是在涉及到复杂模板或者需要强制特定类型转换的时候。
注意：使用显示实例化时，如果传入的参数类型与模板参数类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功，则编译器将会报错。
函数模板的匹配原则
1、一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
#include <iostream>
using namespace std;
// 专门用于int类型加法的非模板函数
// 接收两个const int&（整型常量引用）作为参数，返回它们的和
int Add(const int& x, const int& y)
{
return x + y;
}
// 通用类型加法的函数模板
// 模板参数T代表任意数据类型
// 接收两个const T&（T类型的常量引用）作为参数，返回它们的和
template<typename T>
T Add(const T& x, const T& y)
{
return x + y;
}
int main()
{
int a = 10, b = 20; // 定义两个整数变量a和b
int c = Add(a, b);
// 调用非模板函数Add，这里因为有匹配的非模板函数，所以优先选择它
// 编译器不需要额外实例化模板，因为有精确匹配的非模板函数
int d = Add<int>(a, b);
// 显式调用编译器实例化的Add函数模板，指定T为int类型
// 尽管有非模板函数可用，但通过明确指定模板参数，我们选择了模板版本
return 0;
}当调用
Add(a, b)时，由于存在一个非模板函数与传入参数完全匹配，因此优先调用这个非模板函数。而Add<int>(a, b)则显示指定了使用模板版本并实例化为int类型。
2、对于非模板函数和同名的函数模板，如果其他条件都相同，在调用时会优先调用非模板函数，而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么选择模板
#include <iostream>
using namespace std;
// 专门处理int类型加法的非模板函数
// 接受两个int类型的常量引用，并返回它们的和
int Add(const int& x, const int& y)
{
return x + y;
}
// 通用的加法函数模板，可以处理不同类型的加法
// T1和T2是模板参数，代表任意两种数据类型
// 函数接受T1和T2类型的常量引用参数，并返回T1类型的和
template<typename T1, typename T2>
T1 Add(const T1& x, const T2& y)
{
return x + y;
}
int main()
{
// 调用非模板函数Add，因为参数都是int类型，与非模板函数完全匹配
int a = Add(10, 20);
// 调用函数模板Add，这里T1被推导为double类型，T2为int类型，因为2.2是double
// 注意：虽然结果会被转换为T1类型（这里是double），但原始的int值2仍保持其精度
int b = Add(2.2, 2);
return 0;
}非模板函数完全匹配，不需要函数模板实例化。
函数模板可以生成更加匹配的版本，编译器会根据实参生成更加匹配的Add函数。
3、模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
#include <iostream>
using namespace std;
// 定义一个模板函数Add，用于计算两个同类型数据的和
// T是一个模板参数，代表任意数据类型
template<typename T>
T Add(const T& x, const T& y)
{
return x + y;
}
int main()
{
// 尝试调用Add模板函数，传入一个int(2)和一个double(2.2)
// 这里会引发编译错误，因为模板参数T需要从两个参数类型中统一推导
// 但由于一个参数是int，另一个是double，无法统一到同一个类型T上
int a = Add(2, 2.2); // 这行代码会导致编译错误
return 0; // 表示程序正常结束
}模板函数不允许自动类型转换，所以不会将2自动转换为2.0，或是将2.2自动转换为2。
类模板
类模板的定义格式
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};// 定义一个类模板，名为 Vector，其中 T 是一个模板参数，代表将来实例化时的具体数据类型。
template<class T>
class Vector
{
public :
// 构造函数，初始化容量，默认为10。分配内存并初始化成员变量。
Vector(size_t capacity = 10)
: _pData(new T[capacity]) // 使用 new 分配原始指针指向的内存空间
, _size(0) // 初始化元素数量为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;
};
// 类模板 Vector 的析构函数定义。确保在对象生命周期结束时释放分配的内存。
template <class T>
Vector<T>::~Vector()
{
if(_pData) // 检查指针是否为空，防止重复释放
delete[] _pData; // 释放数组内存
_size = _capacity = 0;
// 将大小和容量置为0，虽然此时对象即将销毁，但这是一种良好的编程习惯
}注意：
- 类模板中的成员函数若是放在类外定义时，需要加模板参数列表。
- 类模板不支持分离编译，即声明在xxx.h文件中，而定义却在xxx.cpp文件中。
类模板的实例化
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后面根<>，然后将实例化的类型放在<>中即可。
实例化为整数型 Vector：
#include <iostream>
int main()
{
// 实例化 Vector 模板，创建一个整数类型的动态数组
Vector<int> intVector;
// 向动态数组中添加元素
intVector.PushBack(10);
intVector.PushBack(20);
intVector.PushBack(30);
// 输出动态数组的大小
std::cout << "Size of intVector: " << intVector.Size() << std::endl;
// 访问并输出动态数组中的元素
for(size_t i = 0; i < intVector.Size(); ++i)
{
std::cout << "Element at index " << i << ": " << intVector[i] << std::endl;
}
return 0;
}实例化为字符串型 Vector：
#include <iostream>
#include <string>
int main()
{
// 实例化 Vector 模板，创建一个字符串类型的动态数组
Vector<std::string> stringVector;
// 向动态数组中添加元素
stringVector.PushBack("Hello");
stringVector.PushBack("World");
// 输出动态数组的大小
std::cout << "Size of stringVector: " << stringVector.Size() << std::endl;
// 访问并输出动态数组中的元素
for(size_t i = 0; i < stringVector.Size(); ++i)
{
std::cout << "Element at index " << i << ": " << stringVector[i] << std::endl;
}
return 0;
}注意：类模板名字不是真正的类，而实例化的结果才是真正的类。