🎯 一、什么是模板？

模板是C++实现泛型编程的核心工具，它允许我们编写与类型无关的代码。可以把它想象成代码的模具——一套代码逻辑，能适应多种数据类型。

为什么需要模板？

// 🔄 传统方式：需要为每种类型写重复代码
void SwapInt(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

void SwapDouble(double& a, double& b) {
    double temp = a;
    a = b;
    b = temp;
}

// ✨ 模板方式：一份代码解决所有类型
template<class T>
void Swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

🎯 二、函数模板

基本语法

// 🎨 模板关键字：template
// 📦 类型参数：typename T 或 class T
template<class T>  // 或 template<typename T>
T Add(T a, T b) {
    return a + b;
}

int main() {
    Add(1, 2);      // T推导为int
    Add(1.5, 2.5);  // T推导为double
}

实例化方式

// 隐式实例化：编译器自动推导
Add(1, 2);          // ✅ 编译器自动推导为int

// 显式实例化：手动指定类型
Add<int>(1, 2.5);   // ✅ 2.5转换为int
Add<double>(1, 2.5); // ✅ 1转换为double

匹配原则

优先级	类型	说明
1️⃣	普通函数	完全匹配时优先
2️⃣	模板函数	需要实例化
3️⃣	自动类型转换	普通函数支持，模板不支持

🎯 三、类模板

基本语法

// 📦 类模板定义
template<class T>
class Stack {
public:
    Stack(int capacity = 4) {
        _array = new T[capacity];
        _size = 0;
    }
    
    // 🚀 压栈操作
    void Push(const T& data) {
        _array[_size++] = data;
    }
    
    ~Stack() {
        delete[] _array;
    }

private:
    T* _array;    // 🔸 模板类型指针
    int _size;    // 🔸 当前大小
};

// 💡 使用示例
Stack<int> intStack;      // 存储int的栈
Stack<double> doubleStack; // 存储double的栈
Stack<string> strStack;    // 存储string的栈

注意：类模板的成员函数在类外定义时也需要模板声明：

template<class T>  // 🔑 必须再次声明模板
void Stack<T>::Push(const T& data) {
    // 实现细节
    if (_size == _capacity) {
        // 扩容逻辑...
    }
    _array[_size++] = data;
}

🎯 四、非类型模板参数

非类型模板参数必须是编译期常量：

// 🔢 N是编译期常量，不是变量
template<class T, int N>  
class Array {
private:
    T _array[N];  // 🏗️ 固定大小数组
public:
    int Size() { return N; }
    T& operator[](int index) {
        return _array[index];
    }
};

// 🎯 使用示例
Array<int, 10> arr1;      // 10个int的数组
Array<double, 100> arr2;  // 100个double的数组

// ❌ 错误示例
// int size = 10;
// Array<int, size> arr3;  // 编译错误！

允许的非类型参数类型：

🎯 五、模板特化

为什么需要特化？

通用模板对某些特殊类型可能无法正确处理，需要特殊处理。

函数模板特化

// 🌐 通用模板
template<class T>
bool IsEqual(T a, T b) {
    return a == b;
}

// ⭐ 针对char*的特化版本
template<>
bool IsEqual<char*>(char* a, char* b) {
    return strcmp(a, b) == 0;
}

// 💡 更推荐的做法：函数重载
bool IsEqual(char* a, char* b) {
    return strcmp(a, b) == 0;
}

类模板特化

全特化

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

// ⭐ 全特化：所有参数都指定
template<>
class Data<int, char> {
public:
    Data() { cout << "特化Data<int, char>" << endl; }
};

偏特化（部分特化）

// 🔧 部分参数特化
template<class T>
class Data<T, int> {
public:
    Data() { cout << "偏特化Data<T, int>" << endl; }
};

// 🎯 参数类型限制：指针版本
template<class T1, class T2>
class Data<T1*, T2*> {
public:
    Data() { cout << "指针特化Data<T1*, T2*>" << endl; }
};

// 🎯 参数类型限制：引用版本
template<class T1, class T2>
class Data<T1&, T2&> {
public:
    Data() { cout << "引用特化Data<T1&, T2&>" << endl; }
};

🎯 六、模板分离编译问题

问题描述

模板声明和定义分离到.h和.cpp文件会导致链接错误：

// 📄 add.h（声明）
template<class T>
T Add(T a, T b);  // 🔴 只有声明

// 📄 add.cpp（定义）
template<class T>
T Add(T a, T b) {
    return a + b;  // 🔴 编译时未实例化
}

// 📄 main.cpp（使用）
#include "add.h"
int main() {
    Add(1, 2);  // 🔴 链接错误！
}

解决方案

1. 声明和定义放在同一个文件（推荐）

   // 📄 add.hpp
   template<class T>
   T Add(T a, T b) {  // ✅ 实现也在头文件
       return a + b;
   }
   

2. 显式实例化（不推荐）

   // 📄 add.cpp
   template<class T>
   T Add(T a, T b) { return a + b; }
   
   // 🔧 显式实例化需要的类型
   template int Add<int>(int, int);
   template double Add<double>(double, double);
   

🎯 七、模板的优缺点

优点 ✅

1. 📦 代码复用：一份代码适应多种类型
2. 🛡️ 类型安全：编译期类型检查，避免运行时错误
3. ⚡ 性能好：编译期实例化，无运行时开销
4. 🔧 灵活性高：支持泛型编程，代码更通用

缺点 ❌

1. 📈 代码膨胀：每种类型都会生成一份代码
2. ⏰ 编译时间长：模板实例化需要额外时间
3. 🐛 调试困难：错误信息冗长复杂，难定位问题
4. 🔗 分离编译问题：需要特殊处理声明和定义

🎯 八、实战示例

实现一个简单的Vector模板

// 🎨 Vector类模板
template<class T>
class Vector {
public:
    // 🏗️ 构造函数
    Vector() : _data(nullptr), _size(0), _capacity(0) {}
    
    // 🚀 添加元素
    void PushBack(const T& val) {
        // 🔄 检查容量
        if (_size == _capacity) {
            _capacity = _capacity == 0 ? 4 : _capacity * 2;
            T* newData = new T[_capacity];
            
            // 📦 复制元素（深拷贝）
            for (int i = 0; i < _size; ++i) {
                newData[i] = _data[i];
            }
            
            delete[] _data;
            _data = newData;
        }
        _data[_size++] = val;
    }
    
    // 🔍 访问元素
    T& operator[](int index) {
        if (index < 0 || index >= _size) {
            throw out_of_range("索引越界");
        }
        return _data[index];
    }
    
    // 📏 获取大小
    int Size() const { return _size; }
    
    // 🧹 析构函数
    ~Vector() { 
        delete[] _data; 
        _data = nullptr;
    }

private:
    T* _data;        // 🔸 数据指针
    int _size;       // 🔸 当前大小
    int _capacity;   // 🔸 总容量
};

// 💡 使用示例
int main() {
    Vector<int> intVec;
    intVec.PushBack(1);
    intVec.PushBack(2);
    intVec.PushBack(3);
    
    cout << "大小: " << intVec.Size() << endl;
    cout << "第一个元素: " << intVec[0] << endl;
    
    Vector<string> strVec;
    strVec.PushBack("Hello");
    strVec.PushBack("World");
    
    return 0;
}

📊 模板应用场景总结

场景	推荐技术	说明
容器类	类模板	vector, list, stack等
算法函数	函数模板	sort, find, swap等
类型无关工具	模板	智能指针、迭代器等
编译期计算	模板元编程	阶乘、斐波那契等
策略模式	模板+特化	不同策略实现

📝 总结与最佳实践

核心要点回顾：

1. 🎯 模板是泛型编程的基础：编写与类型无关的代码
2. 🔧 掌握两种模板：函数模板和类模板
3. ⚡ 理解实例化过程：编译期生成具体代码
4. 🎨 学会特化技巧：处理特殊类型情况
5. 🔗 解决分离编译：声明定义放在一起

最佳实践建议：

• ✅ 优先使用模板：避免代码重复
• ✅ 保持模板简单：复杂的模板难维护
• ✅ 合理使用特化：只对特殊情况使用
• ✅ 注意编译时间：模板过多会影响编译速度
• ✅ 使用类型别名：typedef或using简化模板类型

模板与STL的关系：

模板是C++最强大的特性之一，也是STL（标准模板库）的基石。掌握模板不仅能让你写出更通用的代码，还能深入理解C++的设计哲学。记住：模板是在编译期工作的，它为C++提供了强大的静态多态能力。

---

💡 编程箴言：模板就像代码的乐高积木，类型是不同颜色的积木块，通过组合可以构建出无限可能的数据结构和算法。掌握模板，你就掌握了C++泛型编程的精髓！