模板化编程允许开发者编写与具体类型无关的通用代码，在需要适配不同数据类型时无需重复编写逻辑相似的代码，是提升开发效率的重要编程范式。下面通过多个典型示例展示它的实际应用。
通用数据交换函数
在没有模板化编程时，如果要实现两个变量的交换功能，需要针对不同数据类型分别编写函数，比如针对int、double、string等类型都要写对应的交换逻辑。使用模板化编程可以一次性实现通用交换函数，适配所有支持赋值操作的数据类型。
#include <iostream>
#include <string>
// 通用交换模板函数
template <typename T>
void swap_value(T& a, T& b) {
T temp = a;
a = b;
b = temp;
}
int main() {
// 测试int类型交换
int num1 = 10, num2 = 20;
swap_value(num1, num2);
std::cout << "int交换后: " << num1 << ", " << num2 << std::endl;
// 测试double类型交换
double d1 = 3.14, d2 = 2.71;
swap_value(d1, d2);
std::cout << "double交换后: " << d1 << ", " << d2 << std::endl;
// 测试string类型交换
std::string s1 = "hello", s2 = "world";
swap_value(s1, s2);
std::cout << "string交换后: " << s1 << ", " << s2 << std::endl;
return 0;
}
通用数组最大值查找
查找数组中的最大值也是常见的需求，不同数据类型的数组查找逻辑一致，只是比较的对象类型不同。通过模板化编程可以实现一个通用的查找函数，支持任意可比较类型的数组。
#include <iostream>
#include <cstring>
// 通用数组最大值模板函数
template <typename T>
T find_max(T arr[], int length) {
if (length <= 0) {
return T();
}
T max_val = arr[0];
for (int i = 1; i < length; i++) {
if (arr[i] > max_val) {
max_val = arr[i];
}
}
return max_val;
}
int main() {
int int_arr[] = {1, 3, 5, 2, 4};
int int_max = find_max(int_arr, 5);
std::cout << "int数组最大值: " << int_max << std::endl;
double double_arr[] = {1.2, 3.4, 2.1, 4.5};
double double_max = find_max(double_arr, 4);
std::cout << "double数组最大值: " << double_max << std::endl;
return 0;
}
通用容器类实现
模板化编程还可以用来实现通用的容器类，比如简单的栈结构，无需为int栈、string栈等分别编写类，一个模板类就能适配所有需要的元素类型。
#include <iostream>
#include <vector>
// 通用栈模板类
template <typename T>
class MyStack {
private:
std::vector<T> elements;
public:
void push(const T& val) {
elements.push_back(val);
}
void pop() {
if (!elements.empty()) {
elements.pop_back();
}
}
T top() const {
if (!elements.empty()) {
return elements.back();
}
return T();
}
bool empty() const {
return elements.empty();
}
};
int main() {
MyStack<int> int_stack;
int_stack.push(10);
int_stack.push(20);
std::cout << "int栈顶元素: " << int_stack.top() << std::endl;
MyStack<std::string> str_stack;
str_stack.push("first");
str_stack.push("second");
std::cout << "string栈顶元素: " << str_stack.top() << std::endl;
return 0;
}
类型萃取工具
模板化编程还可以实现类型相关的编译期判断，比如判断某个类型是否为整数类型，这种类型萃取能力在很多基础库的开发中非常实用。
#include <iostream>
#include <type_traits>
// 自定义类型萃取模板
template <typename T>
struct IsInteger {
static const bool value = false;
};
// 针对int类型的特化
template <>
struct IsInteger<int> {
static const bool value = true;
};
// 针对long类型的特化
template <>
struct IsInteger<long> {
static const bool value = true;
};
int main() {
std::cout << "int是否为整数类型: " << IsInteger<int>::value << std::endl;
std::cout << "double是否为整数类型: " << IsInteger<double>::value << std::endl;
std::cout << "long是否为整数类型: " << IsInteger<long>::value << std::endl;
return 0;
}
模板化编程的优势总结
从上述示例可以看出，模板化编程主要解决了重复代码编写的问题，当有逻辑相同但数据类型不同的需求时，无需逐个编写对应类型的代码，通过模板就能生成适配不同场景的实例。同时模板的相关逻辑在编译期处理，不会带来运行时的额外性能开销，还能在编译阶段就发现类型不匹配的问题，提升代码的健壮性。