C++泛型编程：编写“万能”代码的艺术

1. 为什么需要泛型编程？—— 从重复劳动说起

想象一下，你需要一个函数来找出两个数中较大的那个。很简单，对吗？

// 为 int 类型写一个
int max_int(int a, int b) {
    return a > b ? a : b;
}

// 为 double 类型写一个
double max_double(double a, double b) {
    return a > b ? a : b;
}

// 为 string 类型也要一个...
std::string max_string(const std::string& a, const std::string& b) {
    return a > b ? a : b;
}

你很快就会发现一个问题：这些函数的逻辑完全一样，唯一的区别就是处理的数据类型不同。每当有新的类型需要比较大小时，你就得重写一个几乎一模一样的函数。这不仅繁琐，而且难以维护。

泛型编程 (Generic Programming) 的核心思想就是为了解决这个问题：让代码与具体的数据类型解耦，编写出可以被多种不同数据类型复用的“通用”代码。

2. 核心比喻：制造“模具”而非“零件”

传统编程：就像一个手工艺人，需要一个 int 类型的齿轮，就亲手打造一个；需要一个 double 类型的齿轮，就再费力打造另一个。每个零件都是定制的。

泛型编程：我们不再直接打造零件，而是设计一个万能的“模-具” (Template)。这个模具定义了零件的形状和逻辑。

当你需要一个 int 齿轮时，就把“铁水” (int 类型) 注入模具，得到一个 int 齿轮。
当你需要一个 string 齿轮时，就把“塑料” (std::string 类型) 注入模具，得到一个 string 齿轮。

这个**“模具”**在 C++ 中，就是模板 (Template)。

3. 函数模板 (Function Templates)：通用的算法

让我们用模板来改造刚才的 max 函数。

#include <iostream>
#include <string>

// 这里就是我们的“函数模具”
// template <typename T> 告诉编译器：这是一个模板，T 是一个通用的类型占位符。
// T 可以是 int, double, std::string 或任何支持 > 运算符的类型。
template <typename T>
T my_max(T a, T b) {
    // 这里的逻辑和之前完全一样，但现在它不关心 T 具体是什么类型
    return a > b ? a : b;
}

int main() {
    // 1. 将 int “注入”模具
    // 编译器看到你用 int 调用了 my_max，会自动生成一个 int 版本的函数实例
    std::cout << "Max of 3 and 7 is: " << my_max(3, 7) << std::endl;

    // 2. 将 double “注入”模具
    std::cout << "Max of 3.14 and 2.71 is: " << my_max(3.14, 2.71) << std::endl;

    // 3. 将 std::string “注入”模具
    std::string s1 = "hello";
    std::string s2 = "world";
    std::cout << "Max of s1 and s2 is: " << my_max(s1, s2) << std::endl;

    return 0;
}

发生了什么？

我们只写了一遍 my_max 函数。

在编译时，编译器根据你调用的具体类型（int, double, std::string），自动为你生成了三个不同版本的 my_max 函数。这个过程叫做模板实例化 (Template Instantiation)。

你只负责设计模具，编译器负责生产零件。

template 里的 typename 也可以写成 class，即 template ，两者在这里是完全等价的。typename 是更现代、更推荐的写法。

4. 类模板 (Class Templates)：通用的数据结构

函数可以做成模板，类当然也可以。这在数据结构中尤其有用。还记得我们上一课的 MyArray 吗？它只能存储 int。现在我们把它升级成能存储任何类型的通用数组。

#include <iostream>
#include <cstring>

// MyArray 的“类模具”
template <typename T>
class MyArray {
public:
    T* _data;    // 数据指针现在是 T 类型
    int _size;

    // 构造函数
    MyArray(int size) : _size(size) {
        _data = new T[size]; // 分配 T 类型的数组
    }

    // 析构函数
    ~MyArray() {
        delete[] _data;
    }

    // 为了演示，我们简单实现一个打印函数
    void print() const {
        for (int i = 0; i < _size; ++i) {
            std::cout << _data[i] << " ";
        }
        std::cout << std::endl;
    }
    
    // 注意：一个完整的类模板也需要考虑深拷贝（拷贝构造和赋值运算符），
    // 这里为了简化，暂时省略。其实现方式和函数模板类似，也是使用 T。
};

int main() {
    // 实例化一个可以存储 int 的 MyArray
    MyArray<int> intArray(5);
    for(int i = 0; i < 5; ++i) intArray._data[i] = i + 1;
    std::cout << "intArray: ";
    intArray.print();

    // 实例化一个可以存储 double 的 MyArray
    MyArray<double> doubleArray(3);
    doubleArray._data[0] = 1.1;
    doubleArray._data[1] = 2.2;
    doubleArray._data[2] = 3.3;
    std::cout << "doubleArray: ";
    doubleArray.print();

    // 实例化一个可以存储 std::string 的 MyArray
    MyArray<std::string> stringArray(2);
    stringArray._data[0] = "C++";
    stringArray._data[1] = "Rocks!";
    std::cout << "stringArray: ";
    stringArray.print();

    return 0;
}

5. 泛型编程的巅峰：STL (标准模板库)

你可能已经发现，我们自己写的 MyArray 和 C++ 标准库里的 std::vector 非常相似。

没错！整个 STL (Standard Template Library) 就是泛型编程思想的最佳实践。

容器 (Containers)：如 std::vector, std::list, std::map<K, V> 都是类模板。

算法 (Algorithms)：如 std::sort, std::find, std::copy 都是函数模板，它们可以操作各种不同类型的容器。

正是因为有了模板，我们才能用 std::sort 来排序一个 std::vector，也能用它来排序一个 std::list，而不需要为每种容器和类型的组合都写一个排序算法。

总结

泛型编程的核心是模板 (Template)，它允许我们编写与类型无关的代码。

函数模板用于创建通用的算法。

类模板用于创建通用的数据结构。

目的：极大地提高代码的复用性和灵活性，同时保证类型安全（错误会在编译期被发现）。

STL 是 C++ 泛型编程的典范，学习和使用 STL 是掌握泛型编程最快的途径。

掌握了模板，你就拥有了设计“模具”的能力，能够构建出强大、灵活且可复用的 C++ 组件。