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

运行结果会显示不同实例化类型的名称及计算结果。

3. 类型推导规则

编译器会根据实参类型自动推导模板的类型参数 T，主要规则如下：

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

如果实参类型不一致且未显式指定类型，会导致编译错误。例如 add(10, 3.14) 会报错，因为 T 无法同时推导为 int 和 double。解决方式是显式指定类型，如 add<double>(10, 3.14)，编译器会进行隐式类型转换。

4. 重载与特化

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

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

注意：特化模板必须与通用模板在同一作用域，且函数名、参数列表必须与通用模板一致。

三、类模板：通用类的实现

1. 基本语法与实例化

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

#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; // 100
    int_container.set_data(200);
    cout << "int 容器修改后：" << int_container.get_data() << endl; // 200

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

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

    return 0;
}

2. 多参数与非类型参数

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

// 非类型参数：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];}
};

注意：非类型参数不支持浮点数或类类型，仅支持整数、枚举、指针等。

3. 全特化与偏特化

类模板同样支持特化。对于多参数模板，还可以进行偏特化，即为部分模板参数指定类型，保留其他参数的通用性。

#include<iostream>
using namespace std;

// 多参数类模板：T 为元素类型，U 为附加类型
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 << "，第二个值（已乘以 2）：" << second_val * 2 << endl;
    }
private:
    T first_val;
    int second_val;
};

int main(){
    // 通用模板：T=string, U=double
    Pair<string,double> p1("PI", 3.14);
    p1.display();

    // 偏特化 1：T=string, U=int
    Pair<string,int> p2("计数", 5);
    p2.display();

    return 0;
}

四、编译机制与常见问题

1. 编译机制

C++ 模板采用'实例化时编译'机制。模板定义本身不会生成可执行代码，仅当实例化（指定具体类型）时，编译器才会生成对应类型的函数/类代码。因此，模板的声明和定义通常需放在同一翻译单元（.h 文件）中可见，否则可能导致链接错误。

2. 常见错误规避

• 类型推导失败：实参类型不一致时，需显式指定模板类型参数。
• 操作符不支持：传入的类型不支持模板中的运算符时，需重载运算符或使用特化。
• 非类型参数限制：非类型参数必须是编译期常量，不能使用运行时变量。
• 特化不匹配：特化模板的参数列表、返回值类型需与通用模板严格一致。

五、实战案例：通用链表

下面通过一个基于模板实现的通用单向链表类，展示如何支持任意类型的元素存储。

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

通过模板实现的通用链表支持多种类型，代码复用率高，且通过特化为 string 类型提供了美化输出，兼顾了通用性和灵活性。

六、总结

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