C++ 泛型编程与模板详解：从原理到工程实践

这里的 T 就是模板参数，编译器会根据传入的实参类型，自动将 T 替换为 int、double 等具体类型。

2.2 函数模板的原理

很多人误以为函数模板是'一个能处理所有类型的函数'，但实际上并非如此。函数模板本身不是函数，而是编译器生成具体函数的'模具'。

在编译阶段，当我们调用函数模板时，编译器会根据传入的实参类型，推演模板参数 T 的具体类型，然后生成一份专门处理该类型的函数代码。这个过程称为'模板实例化'。

例如调用 Swap(a, b) 时，编译器会分别生成处理 int、double、char 的具体版本。简单来说，函数模板的原理就是'编译器帮我们做重复的工作'，既减少了冗余代码，又降低了维护成本。

2.3 函数模板的实例化

根据是否显式指定模板参数，分为隐式实例化和显式实例化两种。

2.3.1 隐式实例化

隐式实例化是指：编译器根据传入的实参类型，自动推演模板参数 T 的具体类型，无需手动指定。

template<typename T>
T Add(const T& left, const T& right) {
    return left + right;
}

int main() {
    int a1 = 10, a2 = 20;
    Add(a1, a2); // 隐式实例化：T 被推演为 int
    return 0;
}

注意：编译器在隐式实例化时，不会进行自动类型转换。如果传入的实参类型不一致，会直接编译报错。

2.3.2 显式实例化

显式实例化是指：在调用函数时，通过 <> 手动指定模板参数 T 的具体类型。

int main() {
    int a = 10;
    double d = 20.0;
    // 显式实例化：指定 T 为 int，编译器会将 d 隐式转换为 int
    Add<int>(a, d);
    return 0;
}

显式实例化的优势是可以解决实参类型不一致的问题，同时让代码意图更清晰。

2.4 模板参数的匹配原则

当一个非模板函数和同名的函数模板同时存在时，编译器按以下规则匹配：

• 完全匹配优先：如果非模板函数的参数类型与实参完全匹配，优先调用非模板函数。
• 模板更匹配时优先：如果模板可以生成比非模板函数更匹配的版本，优先调用模板实例化的函数。
• 普通函数支持自动类型转换：非模板函数可以进行自动类型转换，但模板函数不支持。

三、类模板

类模板与函数模板类似，常用于实现容器类（如动态数组、链表）。STL 中的 vector、list 等容器，本质上都是类模板的实例化产物。

3.1 类模板的定义格式

类模板的定义需要在类名前声明模板参数，语法如下：

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

注意：类模板中的成员函数如果在类外定义，必须重新声明模板参数列表。

以动态顺序表（Vector）为例：

#include <iostream>
using namespace std;

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) {
        if (_size == _capacity) {
            T* temp = new T[_capacity * 2];
            for (size_t i = 0; i < _size; ++i) temp[i] = _pData[i];
            delete[] _pData;
            _pData = temp;
            _capacity *= 2;
        }
        _pData[_size++] = data;
    }
private:
    T* _pData;
    size_t _size;
    size_t _capacity;
};

template<class T>
Vector<T>::~Vector() {
    if (_pData) {
        delete[] _pData;
        _pData = nullptr;
        _size = 0;
        _capacity = 0;
    }
}

3.2 类模板的实例化

类模板的实例化与函数模板不同：类模板必须显式实例化，即必须在类模板名后加 <>，并指定具体类型。

int main() {
    Vector<int> v1;
    v1.PushBack(10);
    cout << "v1 size: " << v1.Size() << endl;
    return 0;
}

这里的 Vector<int> 和 Vector<double> 是两个完全独立的类，编译器会为它们分别生成对应的代码。

四、非类型模板参数

模板参数不仅可以是'类型占位符'，还可以是编译期可确定的常量，这就是非类型模板参数。

4.1 核心概念与语法

• 类型形参：如 template<class T> 中的 T，代表'待确定的类型'。
• 非类型形参：如 template<class T, size_t N> 中的 N，在模板内部可直接当作常量使用。

经典案例：实现编译期定长数组

namespace bite {
    template<class T, size_t N = 10>
    class Array {
    public:
        T& operator[](size_t index) {
            assert(index < N);
            return _array[index];
        }
    private:
        T _array[N];
    };
}

4.2 关键限制

非类型模板参数有严格的语法约束：

• 不允许的类型：浮点数、类对象、字符串字面量不能作为非类型参数。
• 必须是编译期常量：值必须在编译期就能确定，不能是运行时变量。
• 允许的类型：必须是整型或指针等特定类型。

4.3 核心优势

• 性能优化：避免动态内存分配开销。
• 类型安全：编译期校验常量合法性。
• 灵活性：同一模板可通过不同常量参数生成不同配置版本。

五、模板特化

通用模板能处理大多数类型，但面对指针等特殊类型时，可能出现逻辑错误。模板特化就是为特定类型提供'定制化实现'。

5.1 为什么需要特化？

通用 Less 模板比较指针类型时，默认比较的是指针地址而非指向内容。此时就需要通过模板特化来修正。

5.2 函数模板特化

函数模板特化为特定类型定制函数实现，步骤如下：

1. 必须先有一个基础的函数模板。
2. 关键字 template 后接一对空尖括号 <>。
3. 函数名后接 <特化类型>。

// 基础函数模板
template<class T>
bool Less(T left, T right) {
    return left < right;
}

// 函数模板特化：针对 Date* 类型
template<>
bool Less<Date*>(Date* left, Date* right) {
    return *left < *right;
}

注意：函数模板不建议特化。如果函数模板遇到无法处理的类型，直接写非模板函数重载更简单清晰。

5.3 类模板特化

类模板特化比函数模板特化更常用，分为全特化和偏特化两类。

5.3.1 全特化

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

template<class T1, class T2>
class Data { /* ... */ };

template<>
class Data<int, char> { /* ... */ };

5.3.2 偏特化

偏特化是对模板参数进行进一步的条件限制，有两种表现形式：

• 部分参数特化：将一部分参数确定化，保留其余参数为占位符。
• 参数类型限制：对模板参数的类型进行约束（如限制为指针、引用类型）。

5.3.3 实战：修复 sort 排序指针问题

#include <vector>
#include <algorithm>

template<class T>
struct Less {
    bool operator()(const T& x, const T& y) const {
        return x < y;
    }
};

// 类模板特化：针对 Date* 类型
template<>
struct Less<Date*> {
    bool operator()(Date* x, Date* y) const {
        return *x < *y;
    }
};

5.4 特化优先级规则

当一个类型同时匹配多个模板版本时，编译器按'最具体优先'选择： 全特化 > 偏特化 > 基础模板

六、模板的分离编译：工程化落地避坑

在大型项目中，习惯将声明放在 .h，定义放在 .cpp，但模板的分离编译会导致链接错误。

6.1 为什么模板不能直接分离编译？

模板实例化时机问题导致：

• 编译阶段：.cpp 中只有模板定义，没有具体类型的实例化，因此不会生成任何函数代码。
• 链接阶段：链接器尝试合并文件，但找不到具体类型的实现，导致链接错误。

6.2 解决方案

方案 1：将声明和定义放在同一文件（.h 或 .hpp）

这是最常用、最推荐的方式。直接将模板的声明和定义都写在头文件中：

// a.hpp
template<class T>
T Add(const T& left, const T& right) {
    return left + right;
}

方案 2：显式实例化

在模板定义文件中，显式指定需要实例化的类型：

// a.cpp
template<class T>
T Add(const T& left, const T& right) { return left + right; }

template int Add<int>(const int&, const int&);
template double Add<double>(const double&, const double&);

缺点：灵活性极差，新增类型时必须手动添加显式实例化代码。

七、总结

优点

• 代码复用与效率提升：一份模板代码可适配多种类型，节省开发资源。
• 增强代码灵活性：兼容自定义类型，结合特化、非类型参数等特性，可灵活定制不同场景的逻辑。

缺点

• 代码膨胀与编译耗时：不同类型/参数的模板实例会生成独立的代码，可能导致可执行文件体积增大，增加编译时间。
• 编译错误难定位：模板的编译错误信息通常包含大量嵌套的类型/模板参数信息，提示冗长且不够直观。