C++模板与泛型编程：构建灵活代码架构

2.2 类模板

类模板：是一个通用类定义，使用类型参数代替具体类型

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

// 类模板
template<typename T> class Stack {
public:
    Stack() {}
    void push(const T& value) { data.push_back(value); }
    T pop() {
        if (data.empty()) {
            throw runtime_error("Stack is empty");
        }
        T value = data.back();
        data.pop_back();
        return value;
    }
    T top() const {
        if (data.empty()) {
            throw runtime_error("Stack is empty");
        }
        return data.back();
    }
    bool empty() const { return data.empty(); }
    size_t size() const { return data.size(); }
private:
    vector<T> data;
};

int main() {
    cout << "=== 类模板示例 ===" << endl;
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    intStack.push(3);
    cout << "整数栈的大小：" << intStack.size() << endl;
    cout << "整数栈的顶部元素：" << intStack.top() << endl;
    intStack.pop();
    cout << "整数栈的顶部元素：" << intStack.top() << endl;

    Stack<string> stringStack;
    stringStack.push("apple");
    stringStack.push("banana");
    stringStack.push("cherry");
    cout << "字符串栈的大小：" << stringStack.size() << endl;
    cout << "字符串栈的顶部元素：" << stringStack.top() << endl;
    stringStack.pop();
    cout << "字符串栈的顶部元素：" << stringStack.top() << endl;
    return 0;
}

三、模板参数与模板特化

3.1 模板参数

模板参数：是模板定义中的类型或值参数

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// 带有多个类型参数的函数模板
template<typename T, typename U> pair<T, U> makePair(T first, U second) {
    return {first, second};
}

int main() {
    cout << "=== 模板参数示例 ===" << endl;
    auto intDoublePair = makePair(10, 3.14);
    cout << "整数 - 浮点数对：" << intDoublePair.first << ", " << intDoublePair.second << endl;
    auto stringBoolPair = makePair("hello", true);
    cout << "字符串 - 布尔值对：" << stringBoolPair.first << ", " << stringBoolPair.second << endl;
    return 0;
}

3.2 模板特化

模板特化：是为特定类型或值参数提供专门的实现

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// 通用函数模板
template<typename T> T maxValue(const vector<T>& data) {
    T maxVal = data[0];
    for (const T& value : data) {
        if (value > maxVal) {
            maxVal = value;
        }
    }
    return maxVal;
}

// 模板特化（针对字符串类型）
template<> string maxValue<string>(const vector<string>& data) {
    string maxVal = data[0];
    for (const string& value : data) {
        if (value.length() > maxVal.length()) {
            maxVal = value;
        }
    }
    return maxVal;
}

int main() {
    cout << "=== 模板特化示例 ===" << endl;
    vector<string> stringData = {"apple", "banana", "cherry", "date"};
    cout << "字符串数组的最大值：" << maxValue<string>(stringData) << endl;
    return 0;
}

四、模板元编程

4.1 模板元编程的基本概念

模板元编程：是使用模板在编译期进行计算的编程方法

#include <iostream>
using namespace std;

// 递归模板计算阶乘
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 << "=== 模板元编程示例 ===" << endl;
    cout << "5! = " << Factorial<5>::value << endl;
    cout << "10! = " << Factorial<10>::value << endl;
    return 0;
}

4.2 类型萃取

类型萃取：是在编译期获取类型信息的编程方法

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

// 类型萃取模板
template<typename T> struct TypeTraits {
    static const bool is_integral = false;
    static const bool is_floating_point = false;
};

// 类型萃取特化（针对整数类型）
template<> struct TypeTraits<int> {
    static const bool is_integral = true;
    static const bool is_floating_point = false;
};
template<> struct TypeTraits<long> {
    static const bool is_integral = true;
    static const bool is_floating_point = false;
};

// 类型萃取特化（针对浮点数类型）
template<> struct TypeTraits<float> {
    static const bool is_integral = false;
    static const bool is_floating_point = true;
};
template<> struct TypeTraits<double> {
    static const bool is_integral = false;
    static const bool is_floating_point = true;
};

int main() {
    cout << "=== 类型萃取示例 ===" << endl;
    cout << "int 是整数类型：" << boolalpha << TypeTraits<int>::is_integral << endl;
    cout << "long 是整数类型：" << boolalpha << TypeTraits<long>::is_integral << endl;
    cout << "float 是浮点数类型：" << boolalpha << TypeTraits<float>::is_floating_point << endl;
    cout << "double 是浮点数类型：" << boolalpha << TypeTraits<double>::is_floating_point << endl;
    return 0;
}

五、C++ 标准库中的模板

5.1 模板类

C++ 标准库中的模板类：如 vector、list、map 等

#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <string>
using namespace std;

int main() {
    cout << "=== C++ 标准库中的模板类示例 ===" << endl;
    // vector
    vector<int> vec = {1, 2, 3, 4, 5};
    cout << "vector 的大小：" << vec.size() << endl;
    vec.push_back(6);
    cout << "vector 的大小：" << vec.size() << endl;
    // list
    list<string> strList = {"apple", "banana", "cherry"};
    cout << "list 的大小：" << strList.size() << endl;
    strList.push_front("date");
    cout << "list 的大小：" << strList.size() << endl;
    // map
    map<string, int> strMap = {{"apple", 1}, {"banana", 2}, {"cherry", 3}};
    cout << "map 的大小：" << strMap.size() << endl;
    strMap["date"] = 4;
    cout << "map 的大小：" << strMap.size() << endl;
    return 0;
}

5.2 模板函数

C++ 标准库中的模板函数：如 std::sort、std::find 等

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

int main() {
    cout << "=== C++ 标准库中的模板函数示例 ===" << endl;
    vector<int> vec = {3, 1, 4, 1, 5, 9, 2, 6};
    sort(vec.begin(), vec.end());
    cout << "排序后的 vector: ";
    for (int num : vec) {
        cout << num << " ";
    }
    cout << endl;
    vector<string> strVec = {"apple", "banana", "cherry", "date"};
    auto it = find(strVec.begin(), strVec.end(), "cherry");
    if (it != strVec.end()) {
        cout << "找到元素：" << *it << endl;
    }
    return 0;
}

六、综合案例：实现一个简单的模板库

6.1 项目结构

TemplateLibraryProject/
├── include/
│   └── TemplateLibrary.h
├── src/
│   ├── TemplateLibrary.cpp
│   └── main.cpp
└── build/

6.2 核心代码

// include/TemplateLibrary.h
#ifndef TEMPLATELIBRARY_H
#define TEMPLATELIBRARY_H

#include <iostream>
#include <vector>
#include <algorithm>
#include <type_traits>

using namespace std;

// 函数模板：计算数组的最大值
template<typename T> T maxValue(const vector<T>& data) {
    T maxVal = data[0];
    for (const T& value : data) {
        if (value > maxVal) {
            maxVal = value;
        }
    }
    return maxVal;
}

// 函数模板：计算数组的最小值
template<typename T> T minValue(const vector<T>& data) {
    T minVal = data[0];
    for (const T& value : data) {
        if (value < minVal) {
            minVal = value;
        }
    }
    return minVal;
}

// 函数模板：计算数组的平均值
template<typename T>
typename enable_if<is_arithmetic<T>::value, double>::type averageValue(const vector<T>& data) {
    T sum = 0;
    for (const T& value : data) {
        sum += value;
    }
    return static_cast<double>(sum) / data.size();
}

// 类模板：栈
template<typename T> class Stack {
public:
    Stack() {}
    void push(const T& value) { data.push_back(value); }
    T pop() {
        if (data.empty()) {
            throw runtime_error("Stack is empty");
        }
        T value = data.back();
        data.pop_back();
        return value;
    }
    T top() const {
        if (data.empty()) {
            throw runtime_error("Stack is empty");
        }
        return data.back();
    }
    bool empty() const { return data.empty(); }
    size_t size() const { return data.size(); }
private:
    vector<T> data;
};

// 类模板：队列
template<typename T> class Queue {
public:
    Queue() {}
    void push(const T& value) { data.push_back(value); }
    T pop() {
        if (data.empty()) {
            throw runtime_error("Queue is empty");
        }
        T value = data.front();
        data.erase(data.begin());
        return value;
    }
    T front() const {
        if (data.empty()) {
            throw runtime_error("Queue is empty");
        }
        return data.front();
    }
    bool empty() const { return data.empty(); }
    size_t size() const { return data.size(); }
private:
    vector<T> data;
};

#endif // TEMPLATELIBRARY_H

// src/TemplateLibrary.cpp
#include "TemplateLibrary.h"
// 模板类的实现通常放在头文件中，这里不需要单独实现

// src/main.cpp
#include <iostream>
#include "TemplateLibrary.h"

using namespace std;

int main() {
    cout << "=== 模板库示例 ===" << endl;
    // 使用函数模板
    vector<int> intData = {1, 3, 5, 7, 9};
    cout << "整数数组的最大值：" << maxValue(intData) << endl;
    cout << "整数数组的最小值：" << minValue(intData) << endl;
    cout << "整数数组的平均值：" << averageValue(intData) << endl;
    vector<double> doubleData = {1.2, 3.4, 5.6, 7.8, 9.0};
    cout << "浮点数数组的最大值：" << maxValue(doubleData) << endl;
    cout << "浮点数数组的最小值：" << minValue(doubleData) << endl;
    cout << "浮点数数组的平均值：" << averageValue(doubleData) << endl;

    // 使用类模板
    Stack<string> stringStack;
    stringStack.push("apple");
    stringStack.push("banana");
    stringStack.push("cherry");
    cout << "字符串栈的大小：" << stringStack.size() << endl;
    cout << "字符串栈的顶部元素：" << stringStack.top() << endl;
    stringStack.pop();
    cout << "字符串栈的顶部元素：" << stringStack.top() << endl;

    Queue<int> intQueue;
    intQueue.push(1);
    intQueue.push(2);
    intQueue.push(3);
    cout << "整数队列的大小：" << intQueue.size() << endl;
    cout << "整数队列的头部元素：" << intQueue.front() << endl;
    intQueue.pop();
    cout << "整数队列的头部元素：" << intQueue.front() << endl;
    return 0;
}

6.3 项目构建与运行

# 创建构建目录
mkdir -p build && cd build
# 配置 CMake
cmake ..
# 编译项目
make
# 运行程序
./TemplateLibraryProject

七、总结与练习

7.1 本章总结

本章介绍了 C++ 模板与泛型编程的核心知识，包括：

1. 模板的基本概念，包括函数模板和类模板的定义与使用
2. 模板参数与模板特化，实现通用代码的优化
3. 模板元编程的基本概念，包括递归模板和类型萃取
4. C++ 标准库中的模板类和函数的使用
5. 综合案例：实现一个简单的模板库

7.2 练习题

1. 写一个程序，使用函数模板计算数组的标准差。
2. 编写一个函数，使用模板特化实现对字符串数组的排序。
3. 写一个程序，使用类模板实现一个双向链表。
4. 实现一个类，使用模板元编程计算阶乘。
5. 写一个程序，使用 C++ 标准库中的模板类和函数实现一个简单的学生管理系统。

7.3 进阶挑战

1. 研究如何使用 C++ 的可变参数模板（variadic templates）实现任意数量参数的函数。
2. 学习如何使用 C++ 的模板别名（template aliases）简化模板代码。
3. 研究如何使用 C++ 的概念（Concepts，C++20 及以后）限制模板参数的类型。
4. 学习如何使用 C++ 的 SFINAE（Substitution Failure Is Not An Error）技术实现编译期条件判断。
5. 研究如何使用 C++ 的模板元编程实现编译期类型检查和代码生成。