C++ 泛型编程与模板详解 | 极客日志

C++算法

C++ 泛型编程与模板详解

C++ 泛型编程利用模板实现代码复用。内容涵盖函数模板与类模板的定义、实例化原理（隐式与显式）、参数匹配规则。讲解非类型模板参数在编译期定长数组中的应用及其限制。阐述模板特化机制（全特化与偏特化）解决指针比较等特定类型问题。分析分离编译导致的链接错误及解决方案（头文件包含或显式实例化）。总结模板在提升灵活性的同时存在代码膨胀与编译错误难定位的缺点。

指针猎手发布于 2026/3/160 浏览

一、泛型编程

1.1 为什么需要泛型编程？

先看一个经典的例子：实现交换两个变量的函数。如果不使用模板，我们需要为每种类型编写独立的重载函数：


{  temp = left; left = right; right = temp; }

{  temp = left; left = right; right = temp; }

{  temp = left; left = right; right = temp; }

template<typename T1, typename T2, ..., typename Tn>
返回值类型 函数名 (参数列表) {
    // 函数体（与类型无关的通用逻辑）
}

// 函数模板：通用交换函数
template<typename T>
void Swap(T& left, T& right) {
    T temp = left;
    left = right;
    right = temp;
}

int main() {
    int a = 10, b = 20;
    Swap(a, b); // 传入 int 类型实参
    double c = 3.14, d = 6.28;
    Swap(c, d); // 传入 double 类型实参
    char e = 'A', f = 'B';
    Swap(e, f); // 传入 char 类型实参
    return 0;
}

// 编译器为 int 类型生成的函数
void Swap(int& left, int& right) {
    int temp = left;
    left = right;
    right = temp;
}
// 编译器为 double 类型生成的函数
void Swap(double& left, double& right) {
    double temp = left;
    left = right;
    right = temp;
}
// 编译器为 char 类型生成的函数
void Swap(char& left, char& right) {
    char temp = left;
    left = right;
    right = temp;
}

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
    double d1 = 10.0, d2 = 20.0;
    Add(d1, d2); // 隐式实例化：T 被推演为 double
    return 0;
}

int a = 10;
double d = 20.0;
Add(a, d); // 编译报错：无法确定 T 是 int 还是 double

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

// 非模板函数：专门处理 int 类型
int Add(int left, int right) {
    cout << "非模板函数：";
    return left + right;
}
// 函数模板：通用加法函数
template<typename T1, typename T2>
T1 Add(T1 left, T2 right) {
    cout << "模板函数：";
    return left + right;
}

void Test() {
    Add(1, 2); // 调用非模板函数（完全匹配）
    Add<int>(1, 2); // 调用模板实例化的函数（显式指定模板参数）
    Add(1, 2.0); // 调用模板函数（模板生成 T1=int、T2=double 的版本，更匹配）
}

非模板函数：3
模板函数：3
模板函数：3.0

template<class T>
void print(const T& con) {
    typename T::const_iterator it = con.begin();
    while (it != con.end()) {
        cout << *it << ' ';
        ++it;
    }
}

template<class T1, class T2, ..., class Tn>
class 类模板名 {
    // 类内成员定义（可以使用模板参数 T1、T2...Tn）
};

#include <cassert>
#include <iostream>
using namespace std;

// 类模板：动态顺序表
template<class T>
class Vector {
public:
    // 构造函数：默认容量为 10
    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;
    }

    // 尾删元素
    void PopBack() {
        if (_size > 0) {
            --_size;
        }
    }

    // 获取元素个数
    size_t Size() const {
        return _size;
    }

    // 重载 [] 运算符：支持随机访问
    T& operator[](size_t pos) {
        assert(pos < _size); // 断言：pos 必须合法
        return _pData[pos];
    }

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;
    }
}

int main() {
    // 实例化 int 类型的 Vector：Vector<int>是具体的类
    Vector<int> v1;
    v1.PushBack(10);
    v1.PushBack(20);
    v1.PushBack(30);
    cout << "v1 size: " << v1.Size() << endl; // 输出：3
    for (size_t i = 0; i < v1.Size(); ++i) {
        cout << v1[i] << " "; // 输出：10 20 30
    }
    cout << endl;

    // 实例化 double 类型的 Vector
    Vector<double> v2;
    v2.PushBack(3.14);
    v2.PushBack(6.28);
    cout << "v2 size: " << v2.Size() << endl; // 输出：2
    for (size_t i = 0; i < v2.Size(); ++i) {
        cout << v2[i] << " "; // 输出：3.14 6.28
    }
    cout << endl;
    return 0;
}

#include <cassert>
namespace bite {
    // T：类型参数，N：非类型参数（默认值 10，编译期确定数组大小）
    template<class T, size_t N = 10>
    class Array {
    public:
        // 重载 [] 运算符，支持随机访问
        T& operator[](size_t index) {
            assert(index < N); // 编译期已知 N，索引合法性可提前校验
            return _array[index];
        }
        const T& operator[](size_t index) const {
            assert(index < N);
            return _array[index];
        }
        size_t size() const {
            return N;
        }
        // 大小是编译期常量，无运行时开销
        bool empty() const {
            return N == 0;
        }
    private:
        T _array[N]; // 非类型参数 N 直接用于数组大小定义
    };
}

#include <iostream>
using namespace std;

// 自定义日期类
class Date {
public:
    Date(int year, int month, int day)
        : _year(year), _month(month), _day(day) {}
    bool operator<(const Date& other) const {
        return _year < other._year ||
               (_year == other._year && _month < other._month) ||
               (_year == other._year && _month == other._month && _day < other._day);
    }
private:
    int _year, _month, _day;
};

// 通用 Less 模板：比较两个值的大小
template<class T>
bool Less(T left, T right) {
    return left < right;
}

int main() {
    Date d1(2022, 7, 7), d2(2022, 7, 8);
    cout << Less(d1, d2) << endl; // 正确：比较 Date 对象，输出 1
    Date* p1 = &d1, *p2 = &d2;
    cout << Less(p1, p2) << endl; // 错误：比较指针地址，而非指向的 Date 对象
    return 0;
}

// 基础函数模板（必须先定义）
template<class T>
bool Less(T left, T right) {
    cout << "通用模板：";
    return left < right;
}

// 函数模板特化：针对 Date*类型
template<>
bool Less<Date*>(Date* left, Date* right) {
    cout << "特化模板（Date*）：";
    return *left < *right; // 比较指针指向的内容
}

// 测试代码
int main() {
    Date d1(2022, 7, 7), d2(2022, 7, 8);
    Date* p1 = &d1, *p2 = &d2;
    cout << Less(d1, d2) << endl; // 输出：通用模板：1
    cout << Less(p1, p2) << endl; // 输出：特化模板（Date*）：1（正确）
    return 0;
}

// 直接重载非模板函数，替代特化
bool Less(Date* left, Date* right) {
    return *left < *right;
}

// 基础类模板（两个类型参数）
template<class T1, class T2>
class Data {
public:
    Data() {
        cout << "Data<T1, T2>" << endl;
    }
private:
    T1 _d1;
    T2 _d2;
};

// 全特化：针对 T1=int，T2=char 的组合
template<>
class Data<int, char> {
public:
    Data() {
        cout << "Data<int, char>" << endl;
    }
private:
    int _d1;
    char _d2;
};

// 测试
void Test() {
    Data<double, string> d1; // 调用基础模板：输出 Data<T1, T2>
    Data<int, char> d2;      // 调用全特化版本：输出 Data<int, char>
}

// 基础类模板
template<class T1, class T2>
class Data {
public:
    Data() {
        cout << "Data<T1, T2>" << endl;
    }
};

// 偏特化：第二个参数特化为 int，第一个参数保留为 T1
template<class T1>
class Data<T1, int> {
public:
    Data() {
        cout << "Data<T1, int>" << endl;
    }
};

// 测试
void Test() {
    Data<string, double> d1; // 基础模板：Data<T1, T2>
    Data<double, int> d2;    // 偏特化版本：Data<T1, int>
}

// 偏特化 1：两个参数均为指针类型
template<class T1, class T2>
class Data<T1*, T2*> {
public:
    Data() {
        cout << "Data<T1*, T2*>" << endl;
    }
};

// 偏特化 2：两个参数均为引用类型
template<class T1, class 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 Test() {
    Data<int*, double*> d1;       // 指针偏特化：Data<T1*, T2*>
    Data<int&, double&> d2(10, 20); // 引用偏特化：Data<T1&, T2&>
}

#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; // 比较指针指向的 Date 对象
    }
};

// 测试
int main() {
    Date d1(2022, 7, 7), d2(2022, 7, 6), d3(2022, 7, 8);
    vector<Date*> v = {&d1, &d2, &d3};
    // 使用特化后的 Less<Date*>，排序指针指向的内容
    sort(v.begin(), v.end(), Less<Date*>());
    // 排序后 v 中指针指向的日期顺序：d2(2022-7-6) → d1(2022-7-7) → d3(2022-7-8)
    return 0;
}

// a.h（声明）
template<class T>
T Add(const T& left, const T& right);

// a.cpp（定义）
#include "a.h"
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<int>
    Add(1.0, 2.0); // 调用 Add<double>
    return 0;
}

// a.hpp（声明 + 定义）
template<class T>
T Add(const T& left, const T& right) {
    return left + right;
}

// main.cpp
#include "a.hpp" // 直接包含声明和定义
int main() {
    Add(1, 2);
    Add(1.0, 2.0);
    return 0;
}

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

// 显式实例化 int 和 double 类型
template int Add<int>(const int&, const int&);
template double Add<double>(const double&, const double&);

C++ 泛型编程与模板详解

一、泛型编程

1.1 为什么需要泛型编程？

1.2 模板：泛型编程的基础

二、函数模板

2.1 函数模板的定义格式

2.2 函数模板的原理

2.3 函数模板的实例化

2.3.1 隐式实例化

2.3.2 显式实例化

2.4 模板参数的匹配原则

☃. 小彩蛋：模板中::的二义性问题

三、类模板

3.1 类模板的定义格式

3.2 类模板的实例化

四、非类型模板参数

4.1 核心概念与语法

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

4.2 关键限制

4.3 核心优势

五、模板特化

5.1 为什么需要特化？

5.2 函数模板特化

注意：函数模板不建议特化

5.3 类模板特化

5.3.1 全特化

5.3.2 偏特化

形式 1：部分参数特化

形式 2：参数类型限制

5.3.3 类模板特化实战：修复 sort 排序指针问题

5.4 特化优先级规则

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

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

6.2 解决方案

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

方案 2：显式实例化

七、模版总结

优点：

缺点：

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

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