C++模板与泛型编程：编写灵活高效的通用代码

从具体到抽象：泛型编程的威力

欢迎来到C++编程的又一个重要里程碑！在前面的文章中，我们探索了面向对象编程的强大特性，今天我们将揭开C++另一项核心能力——模板与泛型编程的神秘面纱。泛型编程是一种编写与数据类型无关的通用代码的范式，它让您能够编写出高度可重用、类型安全且性能优异的代码。

想象你正在编写一个比较两个数大小的函数。没有泛型的情况下，你需要为int、float、double等类型分别编写几乎相同的代码。这不仅枯燥，而且难以维护。模板正是为解决这类问题而生，它允许你编写一次代码，然后让编译器为你需要的各种类型生成具体实现。C++标准模板库(STL)正是构建在这一强大特性之上的。

函数模板：通用算法的抽象

基本函数模板

函数模板是生成函数的蓝图，可以处理多种数据类型。让我们从一个简单的例子开始：

#include <iostream>
#include <string>// 函数模板声明
template <typename T>
T max(T a, T b) {return (a > b) ? a : b;
}int main() {std::cout << "max(3, 5): " << max(3, 5) << std::endl;std::cout << "max(3.2, 2.9): " << max(3.2, 2.9) << std::endl;std::cout << "max('a', 'z'): " << max('a', 'z') << std::endl;std::cout << "max(\"hello\", \"world\"): " << max(std::string("hello"), std::string("world")) << std::endl;return 0;
}

在这个例子中：

template <typename T> 声明一个类型参数T
编译器会根据调用时提供的参数类型自动实例化相应版本的函数
同一个模板可以用于int、double、char、std::string等多种类型

多类型参数的函数模板

模板可以接受多个类型参数：

template <typename T1, typename T2>
void printPair(const T1 &first, const T2 &second) {std::cout << "(" << first << ", " << second << ")" << std::endl;
}int main() {printPair(1, 3.14);printPair("Age", 25);printPair(10, "apples");return 0;
}

显式模板参数指定

有时需要显式指定模板参数：

#include <iostream>template <typename T>
void printSize() {std::cout << "Size: " << sizeof(T) << " bytes" << std::endl;
}int main() {printSize<int>();      // 显式指定T为intprintSize<double>();   // 显式指定T为doubleprintSize<char>();     // 显式指定T为charreturn 0;
}

类模板：构建通用数据结构

类模板允许定义可以处理任意类型的数据结构。STL中的vector、list等容器都是类模板的典型应用。

基本类模板示例

让我们实现一个简单的Array类模板：

#include <iostream>
#include <stdexcept> // 用于std::out_of_rangetemplate <typename T, size_t N>
class Array {
private:T data[N];public:// 访问元素T& operator[](size_t index) {if (index >= N) {throw std::out_of_range("Index out of bounds");}return data[index];}// const版本const T& operator[](size_t index) const {if (index >= N) {throw std::out_of_range("Index out of bounds");}return data[index];}// 获取大小size_t size() const { return N; }// 填充数组void fill(const T &value) {for (size_t i = 0; i < N; ++i) {data[i] = value;}}
};int main() {// 创建int类型的数组Array<int, 5> intArray;intArray.fill(10);intArray[2] = 20;for (size_t i = 0; i < intArray.size(); ++i) {std::cout << intArray[i] << " ";}std::cout << std::endl;// 创建string类型的数组Array<std::string, 3> strArray;strArray[0] = "Hello";strArray[1] = "Template";strArray[2] = "World";for (size_t i = 0; i < strArray.size(); ++i) {std::cout << strArray[i] << " ";}std::cout << std::endl;return 0;
}

模板特化：为特定类型定制行为

有时需要对特定类型提供特殊实现，这称为模板特化：

#include <iostream>
#include <cstring> // 用于strcmp// 通用模板
template <typename T>
bool isEqual(T a, T b) {return a == b;
}// const char*的特化版本
template <>
bool isEqual<const char*>(const char* a, const char* b) {return std::strcmp(a, b) == 0;
}int main() {std::cout << std::boolalpha;std::cout << "isEqual(1, 1): " << isEqual(1, 1) << std::endl;std::cout << "isEqual(1.5, 1.6): " << isEqual(1.5, 1.6) << std::endl;std::cout << "isEqual(\"hello\", \"hello\"): " << isEqual("hello", "hello") << std::endl;std::cout << "isEqual(\"hello\", \"world\"): " << isEqual("hello", "world") << std::endl;return 0;
}

模板元编程：编译时计算

C++模板的强大之处在于可以在编译时进行计算和决策，这称为模板元编程(TMP)。

编译时阶乘计算

#include <iostream>// 模板元编程计算阶乘
template <unsigned n>
struct Factorial {static const unsigned value = n * Factorial<n - 1>::value;
};// 特化终止递归
template <>
struct Factorial<0> {static const unsigned value = 1;
};int main() {std::cout << "Factorial<5>::value = " << Factorial<5>::value << std::endl;std::cout << "Factorial<10>::value = " << Factorial<10>::value << std::endl;// 编译时断言检查static_assert(Factorial<5>::value == 120, "Factorial<5> should be 120");return 0;
}

使用constexpr简化编译时计算

C++11引入的constexpr可以更直观地实现编译时计算：

#include <iostream>constexpr unsigned factorial(unsigned n) {return (n <= 1) ? 1 : (n * factorial(n - 1));
}int main() {constexpr unsigned fact5 = factorial(5);std::cout << "5! = " << fact5 << std::endl;// 可以直接用于模板参数std::array<int, factorial(4)> arr; // 数组大小为24return 0;
}

可变参数模板：处理任意数量的参数

C++11引入了可变参数模板，可以处理任意数量和类型的参数。

基本可变参数模板

#include <iostream>// 终止递归的函数
void print() {std::cout << std::endl;
}// 可变参数模板函数
template <typename T, typename... Args>
void print(T first, Args... args) {std::cout << first << " ";print(args...); // 递归调用
}int main() {print(1, 2.5, "hello", 'a');print("Only", "one", "message");print(); // 打印空行return 0;
}

折叠表达式(C++17)

C++17引入了折叠表达式，简化可变参数模板的处理：

#include <iostream>template <typename... Args>
auto sum(Args... args) {return (args + ...); // 折叠表达式
}template <typename... Args>
void printWithSpace(Args... args) {(std::cout << ... << args) << std::endl; // 打印所有参数
}template <typename... Args>
void printWithSeparator(Args... args) {((std::cout << args << " "), ...) << std::endl; // 每个参数后加空格
}int main() {std::cout << "sum(1, 2, 3, 4, 5): " << sum(1, 2, 3, 4, 5) << std::endl;std::cout << "sum(1.5, 2.5, 3.5): " << sum(1.5, 2.5, 3.5) << std::endl;printWithSpace(1, 2, 3, "hello");printWithSeparator(1, 2, 3, "world");return 0;
}

类型萃取与SFINAE

模板元编程中经常需要检查和操作类型特性，C++提供了丰富的类型萃取工具。

使用type_traits

#include <iostream>
#include <type_traits>template <typename T>
void checkType() {std::cout << std::boolalpha;std::cout << "is_integral: " << std::is_integral<T>::value << std::endl;std::cout << "is_floating_point: " << std::is_floating_point<T>::value << std::endl;std::cout << "is_pointer: " << std::is_pointer<T>::value << std::endl;std::cout << "is_class: " << std::is_class<T>::value << std::endl;
}class MyClass {};int main() {std::cout << "--- int ---" << std::endl;checkType<int>();std::cout << "\n--- double ---" << std::endl;checkType<double>();std::cout << "\n--- int* ---" << std::endl;checkType<int*>();std::cout << "\n--- MyClass ---" << std::endl;checkType<MyClass>();return 0;
}

SFINAE (Substitution Failure Is Not An Error)

SFINAE是模板元编程中的重要概念，允许在模板参数推导失败时优雅地回退：

#include <iostream>
#include <type_traits>// 对于有size()方法的类型
template <typename T>
auto printSize(const T &container) -> decltype(container.size(), void()) {std::cout << "Size: " << container.size() << std::endl;
}// 回退版本
void printSize(...) {std::cout << "No size() method" << std::endl;
}int main() {std::string str = "hello";printSize(str); // 调用第一个版本int arr[5] = {1, 2, 3, 4, 5};printSize(arr); // 调用回退版本return 0;
}

实践项目：通用数据结构实现

让我们实现一个简单的通用栈(Stack)类模板，展示模板在实际中的应用：

#include <iostream>
#include <vector>
#include <stdexcept>
#include <memory>template <typename T>
class Stack {
private:std::vector<T> elements;public:// 压栈void push(const T &value) {elements.push_back(value);}// 出栈T pop() {if (empty()) {throw std::out_of_range("Stack<>::pop(): empty stack");}T top = elements.back();elements.pop_back();return top;}// 查看栈顶元素const T& top() const {if (empty()) {throw std::out_of_range("Stack<>::top(): empty stack");}return elements.back();}// 栈是否为空bool empty() const {return elements.empty();}// 栈大小size_t size() const {return elements.size();}// 清空栈void clear() {elements.clear();}
};int main() {// int栈Stack<int> intStack;intStack.push(1);intStack.push(2);intStack.push(3);std::cout << "intStack size: " << intStack.size() << std::endl;while (!intStack.empty()) {std::cout << intStack.pop() << " ";}std::cout << std::endl;// string栈Stack<std::string> strStack;strStack.push("Hello");strStack.push("Template");strStack.push("World");std::cout << "Top element: " << strStack.top() << std::endl;std::cout << "strStack size: " << strStack.size() << std::endl;strStack.pop();std::cout << "After pop, size: " << strStack.size() << std::endl;// 自定义类型栈class Point {int x, y;public:Point(int x, int y) : x(x), y(y) {}friend std::ostream& operator<<(std::ostream &os, const Point &p) {return os << "(" << p.x << "," << p.y << ")";}};Stack<Point> pointStack;pointStack.push(Point(1, 2));pointStack.push(Point(3, 4));while (!pointStack.empty()) {std::cout << pointStack.pop() << " ";}std::cout << std::endl;return 0;
}

这个Stack类模板展示了：