目录
一、函数模板
1、概念
2、格式
3、实例化
4、模板参数的匹配
二、类模板
1、定义格式
2、实例化
交换两个变量的值，针对不同类型，我们可以使用函数重载实现。
void Swap(double& left, double& right)
{
double tmp = left;
left = right;
right = tmp;
}
void Swap(int& left, int& right)
{
int tmp = left;
left = right;
right = tmp;
}- 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数。
- 代码的可维护性比较低，一个出错可能所有的重载均出错。
C++中提供了一种新的方式——泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
一、函数模板
1、概念
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
2、格式
template<typename T1, typename T2,......,typename Tn>返回值类型 函数名(参数列表){ }，typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)。
交换变量值的函数使用函数模板如下：
template<class T>
void Swap(T& x, T& y)
{
T tmp = x;
x = y;
y = tmp;
}简化过程的模板实际上是编译器帮我们处理了复杂的过程。
定义多个模板数：
template<class A,class B>
void Fun{}其实库里包含了swap函数，我们以后可以直接用。
int main()
{
int a = 1, b = 2;
swap(a, b);
double c = 1.1, d = 2.22;
swap(a, b);
return 0;
}3、实例化
函数模板的实例化是指根据函数模板创建具体的函数实例，实例化函数模板的过程是将函数模板中的类型参数替换为实际的类型，并生成对应的函数定义。这样就可以根据不同的类型参数创建多个函数实例，每个实例都可以处理相应类型的数据。
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.11, d2 = 20.22;
Add(a1, a2);
Add(d1, d2);
Add(a1, d1);
return 0;
}
前两个相同类型可以正常编译，但模板参数类型不同时编译出现错误。
这时因为在编译期间，当编译器看到该实例化时，需要推演其实参类型通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T， 编译器无法确定此处到底该将T确定为int 或者 double类型而报错，在模板中，编译器一般不会进行类型转换操作。
我们可以选择强制类型转换解决，或者显示实例化。
方法一：显式类型转换，实参传递给形参，自动推演模板类型。
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.11, d2 = 20.22;
cout << Add(a1, (int)d1) << endl;//显示类型转换
cout << Add((double)a1, d1) << endl;
return 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.11, d2 = 20.22;
cout << Add<int>(a1, d1) << endl;//隐式类型转换
cout << Add<double>(a1, d1) << endl;
return 0;
}
4、模板参数的匹配
下面这两个函数是可以同时存在的。
int Add(int left, int right)
{
return left + right;
}
template<class S>
S Add(S left,S right)
{
return left + right;
}
int main()
{
Add(1, 2);
return 0;
}在Add函数调用处打断点，我们试着观察一下到底会调用哪个函数。
可以发现，Add函数选择了专门处理int的加法函数。
我们也可以通过显示实例化调用函数模板。
3、模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
- 在函数模板中，对于函数参数的类型推断是严格按照实参的类型进行匹配的。如果实参的类型与函数模板参数的类型不完全匹配，编译器将无法进行自动类型转换来匹配函数模板的参数类型。
- 相比之下，普通函数可以进行自动类型转换。当调用普通函数时，如果实参的类型与函数参数的类型不完全匹配，编译器会尝试进行自动类型转换，以便匹配函数参数的类型。这种自动类型转换可以是隐式的，也可以是通过类型转换操作符进行显式的。
二、类模板
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; }
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;
}
在这段代码中，`Vector` 是一个类模板，它并不是一个具体的类，而是一个用于生成具体类的模具或蓝图。当我们使用 `Vector` 类模板时，需要提供具体的类型参数，例如 `Vector<int>` 或 `Vector<double>`，编译器会根据这些类型参数生成对应的具体类。
类模板的定义中使用了模板参数 `T`，它表示一个占位符类型，可以在实例化时被具体的类型替换。在这个例子中，`T` 表示动态顺序表中存储的元素类型。
通过实例化类模板，编译器会根据模板定义生成具体的类，其中的成员函数和成员变量的类型会被替换为实际的类型。例如，`Vector<int>` 实例化后的类将具有 `int* _pData`、`size_t _size` 和 `size_t _capacity` 成员变量，以及相应的成员函数。
因此，`Vector` 并不是一个具体的类，而是一个用于生成具体类的模板。每次使用不同的类型参数实例化 `Vector`，都会生成一个独立的具体类，用于处理特定类型的数据。这样可以提供代码的灵活性和重用性，使得我们可以使用相同的代码逻辑处理不同类型的数据。
2、实例化
Vector类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;
