以下是C++基础教育第八课，聚焦模板与泛型编程，解锁代码复用的终极密码：

---

C++基础教育第八课：模板与泛型编程魔法

一、课程导语

"从重复代码中解放生产力——本节课我们将掌握模板编程技术，学会编写与类型无关的通用代码，领略C++泛型编程的强大魅力。"

二、核心知识点

1. 函数模板基础与特化

2. 类模板与成员模板

3. 模板参数推导规则

4. 可变参数模板与折叠表达式

5. 模板元编程入门

三、实操环节

1. 函数模板基础

(1) 基础函数模板

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

// 定义函数模板
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    cout << "最大整数: " << max(3, 7) << endl;          // T推导为int
    cout << "最大浮点数: " << max(3.14, 2.71) << endl;  // T推导为double
    cout << "最大字符串: " << max(string("apple"), string("banana")) << endl;  // T推导为string

    return 0;
}

模板实例化过程：

• 编译器根据调用时的实参类型生成具体函数版本（模板实例化）

• 每个不同的类型参数组合都会生成独立的函数

---

(2) 显式指定类型参数

int main() {
    // 显式指定T为double（即使实参是int也会强制转换）
    cout << "强制double比较: " << max<double>(3, 7) << endl;  
    return 0;
}

---

(3) 函数模板特化

// 通用模板
template <typename T>
void print(T value) {
    cout << "通用版本: " << value << endl;
}

// 特化版本（针对指针类型）
template <typename T>
void print(T *ptr) {
    cout << "指针特化版本: " << *ptr << endl;
}

// 全特化版本（针对int类型）
template <>
void print<int>(int value) {
    cout << "int全特化版本: " << value * 2 << endl;  // 对int特殊处理
}

int main() {
    int x = 10;
    print(x);     // 调用全特化版本
    print(&x);    // 调用指针特化版本
    print("hello"); // 调用通用模板版本

    return 0;
}

特化规则：

• 全特化：template<> void func<具体类型>(参数)

• 偏特化：仅支持类模板（函数模板不支持偏特化）

---

2. 类模板实战

(1) 基础类模板

#include <vector>
#include <stdexcept>

template <typename T>
class Stack {
public:
    void push(const T &value) {
        data.push_back(value);
    }

    T pop() {
        if(empty()) {
            throw out_of_range("栈为空");
        }
        T value = data.back();
        data.pop_back();
        return value;
    }

    bool empty() const {
        return data.empty();
    }

private:
    vector<T> data;  // 使用STL容器作为底层存储
};

int main() {
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    cout << "弹出: " << intStack.pop() << endl;

    Stack<string> strStack;
    strStack.push("hello");
    cout << "弹出: " << strStack.pop() << endl;

    return 0;
}

类模板特点：

• 模板参数作用于整个类作用域

• 成员函数在调用时才会实例化

---

(2) 类模板成员函数定义

// 类模板声明（头文件中）
template <typename T>
class Calculator {
public:
    T add(T a, T b);
    T multiply(T a, T b);
};

// 成员函数定义（必须在头文件中！）
template <typename T>
T Calculator<T>::add(T a, T b) {
    return a + b;
}

template <typename T>
T Calculator<T>::multiply(T a, T b) {
    return a * b;
}

int main() {
    Calculator<int> intCalc;
    cout << "3 + 5 = " << intCalc.add(3, 5) << endl;

    Calculator<double> doubleCalc;
    cout << "2.5 * 4 = " << doubleCalc.multiply(2.5, 4) << endl;

    return 0;
}

关键注意点：

• 类模板的成员函数定义通常需放在头文件中

• 编译器需要看到完整的模板定义才能实例化

---

3. 模板参数推导进阶

(1) 自动类型推导规则

template <typename T>
void process(T param) { /*...*/ }

int main() {
    int x = 10;
    const int cx = x;
    const int &rx = cx;

    process(x);   // T推导为int
    process(cx);  // T推导为const int
    process(rx);  // T推导为const int（引用被忽略）
    
    const int *ptr = &x;
    process(ptr); // T推导为const int*

    return 0;
}

(2) 引用折叠规则

template <typename T>
void forward(T &&arg) {  // 万能引用（Universal Reference）
    // 实际类型可能是T&或T&&
}

int main() {
    int x = 10;
    forward(x);    // T推导为int& → T&&变为int& && → 折叠为int&
    forward(10);   // T推导为int → T&&变为int&&
    
    const int cx = x;
    forward(cx);   // T推导为const int& → 折叠为const int&
    
    return 0;
}

万能引用要点：

• 形参类型为T&&时，实际类型取决于传入参数

• 结合std::forward实现完美转发

---

4. 可变参数模板

(1) 基础可变参数模板

#include <iostream>

// 终止递归的基函数
void printArgs() {
    cout << endl;
}

// 可变参数模板函数
template <typename T, typename... Args>
void printArgs(T first, Args... args) {
    cout << first << " ";
    printArgs(args...);  // 递归展开参数包
}

int main() {
    printArgs(1, 2.5, "hello", 'A');
    return 0;
}

(2) 折叠表达式（C++17）

#include <iostream>

// 使用折叠表达式求和
template <typename... Args>
auto sum(Args... args) {
    return (... + args);  // 展开为 arg1 + arg2 + arg3...
}

int main() {
    cout << "求和结果: " << sum(1, 2, 3, 4, 5) << endl;
    cout << "字符串连接: " << sum(string("Hello"), string(", "), string("World")) << endl;
    return 0;
}

(3) 参数包展开控制

#include <vector>
#include <iostream>

template <typename... Args>
void pushAll(std::vector<int> &vec, Args... args) {
    // 使用初始化列表展开参数包
    (vec.push_back(args), ...);  // 逗号运算符展开
}

int main() {
    std::vector<int> vec;
    pushAll(vec, 1, 2, 3, 4, 5);
    for(int num : vec) {
        cout << num << " ";
    }
    return 0;
}

---

5. 模板元编程入门

(1) 编译时计算阶乘

template <int N>
struct Factorial {
    static const int value = N * Factorial<N - 1>::value;
};

// 特化终止递归
template <>
struct Factorial<0> {
    static const int value = 1;
};

int main() {
    cout << "5的阶乘: " << Factorial<5>::value << endl;  // 编译时计算
    return 0;
}

(2) 类型萃取示例

#include <type_traits>

template <typename T>
void process(T value) {
    if constexpr (std::is_pointer_v<T>) {  // C++17编译时if
        cout << "处理指针类型: " << *value << endl;
    }
    else {
        cout << "处理普通类型: " << value << endl;
    }
}

int main() {
    int x = 10;
    process(x);     // 普通类型
    process(&x);    // 指针类型
    return 0;
}

---

四、底层原理剖析

1. 模板实例化机制

• 隐式实例化：编译器在遇到模板使用时自动生成具体代码

• 显式实例化（控制代码生成）：

  // 在.cpp文件中显式实例化
  template class Stack<int>;      // 实例化整个类模板
  template void print<double>(double);  // 实例化特定函数
  

2. 模板代码组织原则

• 声明与定义分离问题：

  • 类模板：声明和定义通常都放在头文件

  • 函数模板：定义必须对编译器可见（通常放在头文件）

• 原因：模板代码需要在编译时看到完整定义才能实例化

---

五、课后实战任务

基础挑战

1. 实现通用数组类模板：

   template <typename T, size_t N>
   class Array {
   public:
       T &operator[](size_t index);
       const T &operator[](size_t index) const;
       size_t size() const;
   private:
       T data[N];
   };
   

进阶挑战

1. 实现编译时素数判断：

   template <int N>
   struct IsPrime {
       static constexpr bool value = /*...*/;
   };
   
   // 使用示例：
   static_assert(IsPrime<17>::value, "17应该是素数");
   

2. 设计类型安全的异构容器：

   template <typename... Types>
   class VariantContainer {
   public:
       template <typename T>
       void push(const T &value);  // 存储任意类型
   
       template <typename T>
       T get(size_t index);        // 按类型获取值
   };
   

---

六、常见问题解答

1. Q：模板代码为什么通常放在头文件？

   A：

   • 模板不是真正的代码，而是生成代码的"配方"

   • 编译器需要在看到模板定义的地方实例化具体类型版本

   • 分离编译会导致链接错误（未找到模板实例）

2. Q：函数模板和类模板特化有什么区别？

   A：

   特性	函数模板	类模板
   支持偏特化	❌ 不支持	✅ 支持
   重载优先级	普通函数 > 特化版本 > 通用模板	全特化 > 部分特化 > 通用模板
   实例化时机	调用时	显式或隐式实例化时

3. Q：如何调试模板错误？

   A：

   • 使用static_assert添加编译时检查

   • 分阶段实例化（先测试简单类型）

   • 阅读编译器错误信息（现代编译器如Clang错误提示较友好）

   • 使用typeid(T).name()输出类型信息（需配合c++filt解码）

---

"掌握模板编程，你将突破语言本身的限制，用一套代码解决千万种类型问题——这是C++给予高级开发者的终极武器！"

（推荐阅读《C++ Templates: The Complete Guide》深入理解模板元编程）