模板

模板分为类模板和函数模板

我们先理解一下模板是什么，模板其实就是相当于一个模具，比如我想做一个方形的月饼，那么此时我们是不是需要方形月饼的模具，然后把月饼制作材料放进去，制造方形月饼，并且我们可以根据这个模具做出不同口味的模具，这就是模板。

函数模板：

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

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

格式：

template<class T1, class T2,......,class Tn>(这里把class换成typename也是可以的)

返回值类型  函数名 （参数列表）{}

例子：

比如此时我们想要定义一个swap函数，但是如果这个此时我既想让同为int，char,double类型的交换此时我是不是要写三个swap函数

但是万一我们以后想让更多类型实现交换，照这样下去是不是每一种都得写一个函数，那这太麻烦了，这时，函数模板可以帮我们解决这个问题。

这里用了函数模板，只写了一个模板函数，当调用该函数传参的时候，T会识别传入的参数类型，从而变成对应的参数类型，但是这时如果swap（）传入的参数一个是int一个是double，则会报错，因为这T一开始识别是int，但是后面又发现是double，除非来两个模板参数：tmplate<class T1,class T2>

（注意：这里的函数模板和类模板不可以在别的源文件使用，除非进行显示实例化，这里后续会讲到为什么不行）

函数模板的实例化

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

1. 隐式实例化：

含义​： 你在代码中直接使用模板函数，​编译器根据你传入的实参的类型，自动推导出模板参数T的具体类型，并为你生成一个该特定类型的函数版本（这个过程就是实例化）。你并没有明确告诉编译器 T 是什么。

例如：

​
#include <iostream>
#include <string>

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    // 隐式实例化示例：

    // 编译器看到 5 和 10 是 int 类型
    // 自动推导出 T = int，并生成 int add(int, int) 函数
    int result1 = add(5, 10); // T 被推导为 int
    std::cout << "5 + 10 = " << result1 << std::endl;

    // 编译器看到 3.14 和 2.71 是 double 类型
    // 自动推导出 T = double，并生成 double add(double, double) 函数
    double result2 = add(3.14, 2.71); // T 被推导为 double
    std::cout << "3.14 + 2.71 = " << result2 << std::endl;


    return 0;
}

​

2.显示实例化：

含义​： 你在使用函数时，​主动在尖括号 <> 中明确指定模板参数 T 的具体类型。你明确地告诉编译器：“请生成一个T为指定类型的函数版本来使用”。

例如：

​
#include <iostream>
#include <string>

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    // 显式实例化示例：

    // 明确告诉编译器：请使用 T = int 的版本
    // 编译器会生成 int add(int, int) 并调用它
    int result1 = add<int>(5, 10); // 显式指定 T 为 int
    std::cout << "5 + 10 = " << result1 << std::endl;

    // 明确告诉编译器：请使用 T = double 的版本
    // 编译器会生成 double add(double, double) 并调用它
    // 注意：这里的 5 和 10 会被隐式转换为 double 类型
    double result2 = add<double>(5, 10); // 显式指定 T 为 double
    std::cout << "5.0 + 10.0 = " << result2 << std::endl;


    return 0;
}

​

 模板参数的匹配原则：

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

例如：

// 专门处理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.对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

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

例如：

// 普通函数
int add(int a, int b) {
    return a + b;
}
int main() {
    double x = 5.5;
    char y = 'A'; // 'A' 的 ASCII 码是 65

    // 普通函数调用 - 允许自动类型转换
    int result1 = add(x, y); // 允许调用！
    // 执行过程：
    // 1. double 类型的 x (5.5) 被截断转换为 int (5)
    // 2. char 类型的 y ('A') 被提升转换为 int (65)
    // 3. 调用 add(5, 65)，返回 70

    std::cout << result1 << std::endl; // 输出 70

    return 0;
}

但是模板函数不行，例如：

// 函数模板
template <typename T>
T add(T a, T b) {
    return a + b;
}
int main() {
    double x = 5.5;
    char y = 'A'; // ASCII 码 65

    // 模板函数调用 - 尝试隐式实例化
    // auto result = add(x, y); // 编译错误！

    return 0;
}

类模板：

类模板的定义方式：

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

类模板的实例化：

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

例如：

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

非类型模板参数

模板参数分类类型形参与非类型形参。
1.类型形参：即出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
2.非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

非类型模板参数可以是：

• 整型（如 int, char, size_t）
• 枚举类型
• 指针或引用（指向具有静态存储期的对象）
• C++20 起支持浮点类型

例如：

// 定义一个模板类型的静态数组
template <class T, size_t N = 10>
class array
{
public:
    T &operator[](size_t index) { return _array[index]; }
    const T &operator[](size_t index) const { return _array[index]; }
    size_t size() const { return _size; }
    bool empty() const { return 0 == _size; }

private:
    T _array[N];
    size_t _size;
};

int main()
{
    array<int,10> a1;
    array<int,100> a2;
    return 0;
}

此时N可以根据定义变量时传入的大小而改变

模板特化：

函数模板特化：

函数模板的特化步骤：
1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

例如：此时我们想要比较char*指向的内容而不是地址，所以需要特化isEqual函数

#include <iostream>
#include <cstring> // 用于 strcmp

template <typename T>
bool isEqual(T a, T b) {
    return a == b;
}

// 特化版本
template <>
bool isEqual<const char*>(const char* a, const char* b) {
    return std::strcmp(a, b) == 0;
}

// 特化版本 - 用于char*
template <>
bool isEqual<char*>(char* a, char* b) {
    return std::strcmp(a, b) == 0;
}

int main() {
    // 使用通用模板
    std::cout << "5 == 5: " << isEqual(5, 5) << std::endl;          // true
    std::cout << "3.14 == 2.71: " << isEqual(3.14, 2.71) << std::endl; // false
    
    // 使用特化版本
    const char* str1 = "hello";
    const char* str2 = "hello";
    const char* str3 = "world";
    
    std::cout << "str1 == str2: " << isEqual(str1, str2) << std::endl; // true
    std::cout << "str1 == str3: " << isEqual(str1, str3) << std::endl; // false
    
    char arr1[] = "hello";
    char arr2[] = "world";
    std::cout << "arr1 == arr2: " << isEqual(arr1, arr2) << std::endl; // false
    
    return 0;
}

注意：我们一般不用模板函数特化，因为我们明显可以直接把isEqual函数直接写出char*类型的参数，也就是普通函数，而不是模板的特化。

类模板特化：

1.全特化

全特化即是将模板参数列表中所有的参数都确定化。

例如：

template <class T1, class T2>
class Data
{
public:
    Data() { cout << "Data<T1, T2>" << endl; }

private:
    T1 _d1;
    T2 _d2;
};
template <>
class Data<int, char>
{
public:
    Data() { cout << "Data<int, char>" << endl; }

private:
    int _d1;
    char _d2;
};

2.偏特化

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。

偏特化有以下两种表现方式：
2.1部分特化
将模板参数类表中的一部分参数特化。

// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
    Data() {cout<<"Data<T1, int>" <<endl;}
private:
    T1 _d1;
    int _d2;
};

2.2参数更进一步的限制
偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

例如：

​
​
​template<class T1, class T2>
class Data
{
public:
    Data() {cout<<"Data<T1, T2>" <<endl;}
private:
    T1 _d1;
    T2 _d2;
}；
// 两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data<T1 *, T2 *>
{
public:
    Data() { cout << "Data<T1*, T2*>" << endl; }

private:
    T1 _d1;
    T2 _d2;
};
// 两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data<T1 &, T2 &>
{
public:
    Data(const T1 &d1, const T2 &d2)
        : _d1(d1), _d2(d2)
    {
        cout << "Data<T1&, T2&>" << endl;
    }

private:
    const T1 &_d1;
    const T2 &_d2;
};
void test2()
{

    Data<int , double> d2; // 调用基础的模板
    Data<int *, int *> d3;       // 调用特化的指针版本
    Data<int &, int &> d4(1, 2); // 调用特化的指针版本
}
​

分离编译：

什么是分离编译？

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：

// a.h
template<class T>
T Add(const T& left, const T& right);
// a.cpp
template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
}
// main.cpp
#include"a.h"
int main()
{
    Add(1, 2);
    Add(1.0, 2.0);
    return 0;
}

当我们运行上述代码的时候，编译器会报一个链接错误，这是为什么呢？

模板代码在编译时需要实例化。当编译器处理main.cpp时，它从a.h看到了Add的声明，但不知道如何实例化它。当编译器处理a.cpp时，它看到了模板的定义，但没有看到任何使用该模板的代码，因此没有实例化任何具体版本。

在我们运行c/c++的程序时，会有以下几个步骤：

1.预处理---展开头文件/宏替换/去掉注释/条件编译

a.i

2.编译---检查语法，生成汇编代码（头文件不参与编译，编译器对工程中的多个源文件是分离开单独编译的）

a.s

3.汇编---将汇编代码转成二进制机器码

a.o

4.链接---将目标文件整合

而函数调用是需要地址的，由于没有实例化，所以链接的时候main函数找不到a.cpp的对应的add函数的地址。

解决方法：

1、将模板定义放在头文件中（最常见）

2、显式实例化模板

例如：

#include "template_ops_explicit.h"

// 模板定义
template <typename T>
T templateAdd(T a, T b) {
    return a + b;
}

// 显式实例化
template<>
int templateAdd<int>(int, int);
template<>
double templateAdd<double>(double, double);