在C++中实现高可重用性的代码是许多开发者所追求的目标，而模版（Templates）和策略模式（Strategy Pattern）是帮助实现这一目标的强大工具。这篇文章将介绍如何利用这些工具在C++框架中实现代码的可重用性，涵盖基本概念、实现方法以及示例代码。
模版的基本概念
模版是C++中创建泛型代码的主要工具。通过模版，函数和类可以在参数化类型的基础上实现，从而使得代码在不同类型数据上可以重用。模版分为函数模版和类模版。
函数模版
函数模版允许编写一个函数模板，从而可以处理不同类型的数据。下面是一个简单的函数模版示例，它实现了一个泛型的最大值函数：
template <typename T>
T max(T a, T b) {
return (a > b) ? a : b;
}
这样，你可以使用max函数处理int、double或任意其他支持比较操作的类型。
类模版
类模版允许创建适用于各种数据类型的类。以下是一个简单的类模版示例，它实现了一个栈（stack）数据结构：
template <typename T>
class Stack {
private:
std::vector<T> elements;
public:
void push(const T& element) {
elements.push_back(element);
}
void pop() {
if (!elements.empty()) {
elements.pop_back();
}
}
T top() const {
if (!elements.empty()) {
return elements.back();
}
}
bool empty() const {
return elements.empty();
}
};
策略模式的基本概念
策略模式是一种行为设计模式，它允许在运行时选择算法。通过这个模式，可以定义一系列算法，把每一个算法封装起来，并且使它们之间可以互相替换。策略模式主要由三个部分组成：策略接口、具体策略类和上下文类。
策略接口
策略接口是所有具体策略类的通用接口。可以用纯虚函数来定义这个接口：
class Strategy {
public:
virtual ~Strategy() {}
virtual void doAlgorithm() const = 0;
};
具体策略类
具体策略类实现了策略接口定义的算法。以下是两个具体策略类的示例：
class ConcreteStrategyA : public Strategy {
public:
void doAlgorithm() const override {
std::cout << "Algorithm A" << std::endl;
}
};
class ConcreteStrategyB : public Strategy {
public:
void doAlgorithm() const override {
std::cout << "Algorithm B" << std::endl;
}
};
上下文类
上下文类使用策略对象，而不直接实现具体算法。以下是上下文类的示例：
class Context {
private:
Strategy* strategy;
public:
Context(Strategy* strategy = nullptr) : strategy(strategy) {}
void setStrategy(Strategy* strategy) {
this->strategy = strategy;
}
void executeStrategy() const {
if (strategy) {
strategy->doAlgorithm();
}
}
};
模版和策略模式结合
将模版与策略模式结合使用可以进一步提高代码的可重用性和灵活性。例如，可以用模版参数化上下文类，以便可以使用任何类型的策略：
template <typename T>
class Context {
private:
T strategy;
public:
Context(T strategy = T()) : strategy(strategy) {}
void setStrategy(T strategy) {
this->strategy = strategy;
}
void executeStrategy() const {
strategy.doAlgorithm();
}
};
这样，Context类可以与任何实现了doAlgorithm方法的策略类一起使用，而无需修改上下文类的代码。以下是一种结合模版和策略模式的完整示例：
// 策略接口和具体策略类
class Strategy {
public:
virtual ~Strategy() {}
virtual void doAlgorithm() const = 0;
};
class ConcreteStrategyA : public Strategy {
public:
void doAlgorithm() const override {
std::cout << "Algorithm A" << std::endl;
}
};
class ConcreteStrategyB : public Strategy {
public:
void doAlgorithm() const override {
std::cout << "Algorithm B" << std::endl;
}
};
// 上下文类
template <typename T>
class Context {
private:
T strategy;
public:
Context(T strategy = T()) : strategy(strategy) {}
void setStrategy(T strategy) {
this->strategy = strategy;
}
void executeStrategy() const {
strategy.doAlgorithm();
}
};
// 客户端代码
int main() {
ConcreteStrategyA strategyA;
ConcreteStrategyB strategyB;
Context<ConcreteStrategyA> contextA(strategyA);
contextA.executeStrategy();
Context<ConcreteStrategyB> contextB(strategyB);
contextB.setStrategy(strategyA); // 这里需要注意，应该提供相应的类型匹配策略
contextB.executeStrategy();
return 0;
}
通过结合使用模版和策略模式，可以有效提高C++代码的可重用性和灵活性，同时还能降低代码的耦合度，使得程序更加模块化和易于维护。