C++ 模板编程基础：泛型编程入门与实践

定义与调用示例

来看个通用加法函数的例子，它支持任意支持 + 运算符的类型。

#include <iostream>
using namespace std;

// 函数模板：通用加法函数
template<typename T>
T add(T a, T b) {
    cout << "模板函数调用，类型为：" << typeid(T).name() << endl;
    return a + b;
}

int main() {
    // 1. 显式指定类型参数（推荐，可读性强）
    int num1 = add<int>(10, 20);
    cout << "int 类型加法：10 + 20 = " << num1 << endl;

    double num2 = add<double>(3.14, 2.86);
    cout << "double 类型加法：3.14 + 2.86 = " << num2 << endl;

    // 2. 隐式推导类型参数（编译器根据实参类型自动推导 T）
    float num3 = add(5.5f, 3.5f);
    cout << "float 类型加法：5.5 + 3.5 = " << num3 << endl;

    string str1 = "Hello, ", str2 = "C++!";
    string str3 = add(str1, str2); // 字符串支持 + 运算符，推导 T 为 string
    cout << "string 类型加法：" << str3 << endl;

    return 0;
}

运行结果：

模板函数调用，类型为：int int 类型加法：10 + 20 = 30
模板函数调用，类型为：double double 类型加法：3.14 + 2.86 = 6
模板函数调用，类型为：float float 类型加法：5.5 + 3.5 = 9
模板函数调用，类型为：std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > string 类型加法：Hello, C++!

类型推导规则

编译器会根据实参类型自动推导模板的类型参数 T，但需注意以下规则：

1. 实参类型必须一致（若函数参数均为 T 类型），否则推导失败。
2. 引用/const 修饰会被保留或忽略（需注意类型匹配）。
3. 数组、函数会退化为指针类型（除非显式指定为引用）。

注意： 若实参类型不一致且未显式指定类型，会导致编译错误。

// 错误：实参类型分别为 int 和 double，T 无法推导
add(10, 3.14); // 编译错误：no matching function for call to 'add(int, double)'

// 解决：显式指定类型，编译器会进行隐式类型转换（若支持）
add<double>(10, 3.14); // 正确，10 被转换为 double 类型

重载与特化

函数模板的重载

函数模板支持重载，可与普通函数或其他函数模板构成重载关系，调用时遵循'最匹配原则'：

1. 普通函数优先于模板函数（若参数完全匹配）。
2. 模板函数的显式特化优先于通用模板。
3. 更具体的模板优先于更通用的模板。

函数模板的特化

当通用模板无法满足特定类型的需求时，可对模板进行特化（Specialization），为特定类型提供专属实现。

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

// 通用函数模板：加法
template<typename T>
T add(T a, T b) {
    cout << "通用模板：";
    return a + b;
}

// 特化：为 string 类型提供专属实现（拼接字符串时添加空格）
template<>
string add<string>(string a, string b) {
    cout << "string 特化模板：";
    return a + " " + b; // 特殊逻辑：拼接时添加空格
}

int main() {
    cout << add(10, 20) << endl; // 通用模板：30
    cout << add(3.14, 2.86) << endl; // 通用模板：6
    cout << add(string("Hello"), string("World")) << endl; // string 特化模板：Hello World
    return 0;
}

类模板：通用类的实现

基本语法与实例化

类模板用于创建通用类，支持不同类型的成员变量和成员函数参数。类模板不能直接使用，需实例化（指定具体类型）后才能创建对象。

#include <iostream>
using namespace std;

// 类模板：通用容器类（存储单个元素）
template<typename T>
class Container {
private:
    T data; // 成员变量，类型为 T
public:
    // 构造函数
    Container(T value) : data(value) {}

    // 成员函数：类内定义
    T get_data() const {
        return data;
    }

    // 成员函数：类外定义（需再次声明模板参数）
    void set_data(T value);
};

// 类外定义成员函数：必须加 template <typename T>
template<typename T>
void Container<T>::set_data(T value) {
    data = value;
}

int main() {
    // 1. 显式实例化（推荐，可读性强）
    Container<int> int_container(100);
    cout << "int 容器初始值：" << int_container.get_data() << endl;
    int_container.set_data(200);
    cout << "int 容器修改后：" << int_container.get_data() << endl;

    // 2. 隐式实例化（编译器根据构造函数参数推导类型）
    Container<double> double_container(3.14);
    cout << "double 容器值：" << double_container.get_data() << endl;

    // 3. 实例化不同类型的对象（相互独立）
    Container<string> str_container("Hello C++");
    cout << "string 容器值：" << str_container.get_data() << endl;

    return 0;
}

多参数与非类型参数

类模板支持多个类型参数，也支持非类型参数（必须是编译期可确定的常量）。

// 非类型参数：N 为常量整数（必须是编译期可确定的值）
template<typename T, int N>
class Array {
private:
    T data[N]; // 固定大小的数组，N 为模板参数
public:
    int size() const {
        return N;
    }
    T& operator[](int index) {
        return data[index];
    }
};

限制： 非类型参数不支持浮点数、类类型（如 string）作为参数。

类模板的特化与偏特化

全特化

为所有模板参数指定具体类型。

// 通用类模板
template<typename T>
class Printer {
public:
    void print(T value) {
        cout << "通用模板 - 类型：" << typeid(T).name() << "，值：" << value << endl;
    }
};

// 全特化：为 string 类型提供专属实现
template<>
class Printer<string> {
public:
    void print(string value) {
        cout << "string 特化模板 - 字符串：\"" << value << "\"" << endl;
    }
};

偏特化

为部分模板参数指定类型，保留其他参数的通用性。

// 多参数类模板
template<typename T, typename U>
class Pair {
public:
    Pair(T first, U second) : first_val(first), second_val(second) {}
    void display() {
        cout << "通用模板 - 第一个值：" << first_val << "，第二个值：" << second_val << endl;
    }
private:
    T first_val;
    U second_val;
};

// 偏特化 1：当第二个参数 U 为 int 时的专属实现
template<typename T>
class Pair<T, int> {
public:
    Pair(T first, int second) : first_val(first), second_val(second) {}
    void display() {
        cout << "偏特化（U=int） - 第一个值：" << first_val << "，第二个值（整数）：" << second_val * 2 << endl;
    }
private:
    T first_val;
    int second_val;
};

编译机制与常见问题

编译机制

C++ 模板采用'实例化时编译'机制。模板定义本身不会生成可执行代码，仅当实例化（指定具体类型）时，编译器才会生成对应类型的函数/类代码。

关键点： 模板的声明和定义需在同一翻译单元（.cpp 文件）中可见，否则会导致链接错误（'未定义的引用'）。通常建议将模板的声明和定义放在同一 .h 文件中。

常见错误规避

1. 类型推导失败：确保实参类型一致，或显式指定模板类型参数。
2. 模板参数不支持特定操作：为自定义类重载所需运算符，或使用模板特化。
3. 非类型参数不是编译期常量：非类型参数使用字面量、const 变量、enum 值等。
4. 模板特化与通用模板不匹配：特化模板的参数列表、返回值类型需与通用模板严格一致。

实战案例：基于模板实现通用链表

这里我们实现一个通用单向链表类，支持任意类型的元素存储，通过模板实现类型无关性。

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

// 1. 链表节点类模板
template<typename T>
class ListNode {
public:
    T data; // 节点数据（通用类型 T）
    ListNode<T>* next; // 下一个节点指针

    // 构造函数
    ListNode(T value) : data(value), next(nullptr) {}
};

// 2. 链表类模板
template<typename T>
class LinkedList {
private:
    ListNode<T>* head; // 头节点指针
    int length; // 链表长度
public:
    // 构造函数：初始化空链表
    LinkedList() : head(nullptr), length(0) {}

    // 析构函数：释放所有节点内存
    ~LinkedList() {
        ListNode<T>* curr = head;
        while (curr != nullptr) {
            ListNode<T>* temp = curr;
            curr = curr->next;
            delete temp;
        }
        head = nullptr;
        length = 0;
    }

    // 头插法：在链表头部插入元素
    void push_front(T value) {
        ListNode<T>* new_node = new ListNode<T>(value);
        new_node->next = head;
        head = new_node;
        length++;
    }

    // 尾插法：在链表尾部插入元素
    void push_back(T value) {
        ListNode<T>* new_node = new ListNode<T>(value);
        if (head == nullptr) {
            head = new_node;
        } else {
            ListNode<T>* curr = head;
            while (curr->next != nullptr) {
                curr = curr->next;
            }
            curr->next = new_node;
        }
        length++;
    }

    // 按索引插入元素
    bool insert(int index, T value) {
        if (index < 0 || index > length) {
            cout << "插入失败：索引" << index << "非法！" << endl;
            return false;
        }
        if (index == 0) {
            push_front(value);
            return true;
        }
        ListNode<T>* curr = head;
        for (int i = 0; i < index - 1; ++i) {
            curr = curr->next;
        }
        ListNode<T>* new_node = new ListNode<T>(value);
        new_node->next = curr->next;
        curr->next = new_node;
        length++;
        return true;
    }

    // 按值删除第一个匹配的元素
    bool remove(T value) {
        if (head == nullptr) {
            cout << "删除失败：链表为空！" << endl;
            return false;
        }
        ListNode<T>* curr = head;
        ListNode<T>* prev = nullptr;
        while (curr != nullptr && curr->data != value) {
            prev = curr;
            curr = curr->next;
        }
        if (curr == nullptr) {
            cout << "删除失败：未找到值" << value << "！" << endl;
            return false;
        }
        if (prev == nullptr) {
            head = curr->next;
        } else {
            prev->next = curr->next;
        }
        delete curr;
        length--;
        return true;
    }

    // 按索引查找元素
    T get(int index) const {
        if (index < 0 || index >= length) {
            cout << "查找失败：索引" << index << "非法！" << endl;
            return T();
        }
        ListNode<T>* curr = head;
        for (int i = 0; i < index; ++i) {
            curr = curr->next;
        }
        return curr->data;
    }

    // 获取链表长度
    int size() const {
        return length;
    }

    // 遍历打印链表（通用版本）
    void print() const {
        if (head == nullptr) {
            cout << "链表为空！" << endl;
            return;
        }
        cout << "链表元素（长度" << length << "）：";
        ListNode<T>* curr = head;
        while (curr != nullptr) {
            cout << curr->data << " -> ";
            curr = curr->next;
        }
        cout << "nullptr" << endl;
    }
};

// 3. 特化：为 string 类型提供专属 print 函数（美化输出）
template<>
void LinkedList<string>::print() const {
    if (head == nullptr) {
        cout << "链表为空！" << endl;
        return;
    }
    cout << "字符串链表（长度" << length << "）：";
    ListNode<string>* curr = head;
    while (curr != nullptr) {
        cout << "\"" << curr->data << "\" -> ";
        curr = curr->next;
    }
    cout << "nullptr" << endl;
}

// 测试代码
int main() {
    // 测试 int 类型链表
    cout << "===== 测试 int 类型链表 =====" << endl;
    LinkedList<int> int_list;
    int_list.push_back(10);
    int_list.push_back(20);
    int_list.push_front(5);
    int_list.insert(2, 15);
    int_list.print();
    cout << "索引 2 的元素：" << int_list.get(2) << endl;
    int_list.remove(10);
    int_list.print();

    // 测试 string 类型链表（特化 print）
    cout << "\n===== 测试 string 类型链表 =====" << endl;
    LinkedList<string> str_list;
    str_list.push_back("Apple");
    str_list.push_back("Banana");
    str_list.push_front("Orange");
    str_list.insert(1, "Grape");
    str_list.print();
    str_list.remove("Grape");
    str_list.print();

    // 测试 double 类型链表
    cout << "\n===== 测试 double 类型链表 =====" << endl;
    LinkedList<double> double_list;
    double_list.push_back(1.1);
    double_list.push_back(2.2);
    double_list.push_front(0.5);
    double_list.print();

    return 0;
}

结论： 通过模板实现的通用链表支持 int、string、double 等多种类型，代码复用率高，且通过特化为 string 类型提供了美化输出，兼顾了通用性和灵活性。实际开发中，类似 STL 的 vector、list 等容器均采用类似的模板设计。

模板与 STL 的关联

STL（Standard Template Library，标准模板库）是 C++ 泛型编程的典范，其核心组件（容器、算法、迭代器）均基于模板实现：

1. 容器：vector、list、map<K,V> 等均为类模板。
2. 算法：sort、find、reverse 等均为函数模板。
3. 迭代器：作为容器与算法的桥梁，也是模板类型。

掌握模板编程后，能更深入理解 STL 的设计思想，甚至自定义适配 STL 的容器或算法。

总结

1. 模板是 C++ 泛型编程的核心，分为函数模板和类模板，核心价值是'一次编写，多次复用'，兼顾类型安全和灵活性。
2. 函数模板支持显式/隐式实例化、重载、特化，适用于创建通用函数。
3. 类模板支持多参数、非类型参数、全特化、偏特化，适用于创建通用容器。
4. 模板的编译机制为'实例化时编译'，需注意声明与定义的一致性，避免链接错误。
5. 模板是 STL 的底层实现基础，掌握模板编程是深入学习 STL 和 C++ 高级特性的关键。