模板和泛型编程
概述
模板和泛型编程是C++中非常重要的特性，它们允许你编写通用的代码，这些代码可以处理多种数据类型，而不需要为每种数据类型编写单独的代码。模板是C++实现泛型编程的基础，它使得代码更加灵活和可重用。
模板的基本概念
什么是模板？
模板是一种通用代码的蓝图，它允许你在编写代码时使用类型参数。模板可以用于函数和类，使得这些函数和类可以处理不同类型的数据。
模板的优势
- 代码重用：模板允许你编写一次代码，然后在不同的上下文中使用它。
- 类型安全：模板在编译时进行类型检查，确保类型安全。
- 灵活性：模板可以处理多种数据类型，使得代码更加灵活。
函数模板
定义函数模板
函数模板允许你定义一个通用的函数，该函数可以处理多种数据类型。函数模板的定义使用关键字 template 和 typename 或 class。
template <typename T>
T add(T a, T b) {
return a + b;
}
使用函数模板
你可以使用函数模板来处理不同类型的数据。编译器会根据传入的参数类型自动推导模板参数。
#include <iostream>
int main() {
std::cout << add(1, 2) << std::endl; // 输出: 3
std::cout << add(1.5, 2.5) << std::endl; // 输出: 4.0
std::cout << add('a', 'b') << std::endl; // 输出: 195 (ASCII码相加)
return 0;
}
实践练习
编写一个函数模板 max，返回两个数中的最大值。
template <typename T>
T max(T a, T b) {
return (a > b) ? a : b;
}
int main() {
std::cout << max(3, 7) << std::endl; // 输出: 7
std::cout << max(3.5, 2.5) << std::endl; // 输出: 3.5
std::cout << max('a', 'b') << std::endl; // 输出: b
return 0;
}
类模板
定义类模板
类模板允许你定义一个通用的类，该类可以处理多种数据类型。类模板的定义同样使用关键字 template 和 typename 或 class。
template <typename T>
class Box {
public:
Box(T value) : value(value) {}
T getValue() const {
return value;
}
private:
T value;
};
使用类模板
你可以使用类模板来创建不同类型的对象。
int main() {
Box<int> intBox(123);
Box<double> doubleBox(123.456);
Box<std::string> stringBox("Hello, World!");
std::cout << intBox.getValue() << std::endl; // 输出: 123
std::cout << doubleBox.getValue() << std::endl; // 输出: 123.456
std::cout << stringBox.getValue() << std::endl; // 输出: Hello, World!
return 0;
}
实践练习
编写一个类模板 Pair，存储两个不同类型的值。
template <typename T1, typename T2>
class Pair {
public:
Pair(T1 first, T2 second) : first(first), second(second) {}
T1 getFirst() const {
return first;
}
T2 getSecond() const {
return second;
}
private:
T1 first;
T2 second;
};
int main() {
Pair<int, double> pair1(1, 2.5);
Pair<std::string, char> pair2("Hello", 'A');
std::cout << pair1.getFirst() << ", " << pair1.getSecond() << std::endl; // 输出: 1, 2.5
std::cout << pair2.getFirst() << ", " << pair2.getSecond() << std::endl; // 输出: Hello, A
return 0;
}
模板特化
什么是模板特化？
模板特化允许你为特定的类型提供特定的实现。当你需要为某些特定类型提供不同的行为时，可以使用模板特化。
函数模板特化
template <typename T>
T add(T a, T b) {
return a + b;
}
// 特化版本，处理字符串
template <>
std::string add(std::string a, std::string b) {
return a + " " + b;
}
int main() {
std::cout << add(1, 2) << std::endl; // 输出: 3
std::cout << add(std::string("Hello"), std::string("World")) << std::endl; // 输出: Hello World
return 0;
}
类模板特化
template <typename T>
class Box {
public:
Box(T value) : value(value) {}
T getValue() const {
return value;
}
private:
T value;
};
// 特化版本，处理字符串
template <>
class Box<std::string> {
public:
Box(std::string value) : value(value) {}
std::string getValue() const {
return "String: " + value;
}
private:
std::string value;
};
int main() {
Box<int> intBox(123);
Box<std::string> stringBox("Hello, World!");
std::cout << intBox.getValue() << std::endl; // 输出: 123
std::cout << stringBox.getValue() << std::endl; // 输出: String: Hello, World!
return 0;
}
实践练习
编写一个函数模板 print，并为其特化一个版本，专门处理 std::vector<int>。
#include <iostream>
#include <vector>
template <typename T>
void print(T value) {
std::cout << value << std::endl;
}
// 特化版本，处理 std::vector<int>
template <>
void print(std::vector<int> vec) {
for (int num : vec) {
std::cout << num << " ";
}
std::cout << std::endl;
}
int main() {
print(123); // 输出: 123
print(std::string("Hello")); // 输出: Hello
print(std::vector<int>{1, 2, 3}); // 输出: 1 2 3
return 0;
}
模板元编程
什么是模板元编程？
模板元编程是一种在编译时执行计算的技术。通过使用模板，你可以在编译时生成代码，而不是在运行时。模板元编程可以用于编写高效的代码，减少运行时开销。
简单的模板元编程示例
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() {
std::cout << Factorial<5>::value << std::endl; // 输出: 120
return 0;
}
实践练习
编写一个模板元编程程序，计算斐波那契数列的第N项。
template <int N>
struct Fibonacci {
static const int value = Fibonacci<N - 1>::value + Fibonacci<N - 2>::value;
};
template <>
struct Fibonacci<0> {
static const int value = 0;
};
template <>
struct Fibonacci<1> {
static const int value = 1;
};
int main() {
std::cout << Fibonacci<10>::value << std::endl; // 输出: 55
return 0;
}
总结
模板和泛型编程是C++中非常强大的特性，它们允许你编写通用的代码，这些代码可以处理多种数据类型。通过函数模板和类模板，你可以编写灵活且可重用的代码。模板特化和模板元编程进一步扩展了模板的功能，使得你可以在编译时执行复杂的计算。
通过本教程的学习，你应该能够理解模板的基本概念，并能够编写简单的函数模板和类模板。希望你能继续深入学习，掌握更多高级的模板技巧。