飞翔的十号1. 策略模式的核心概念回顾
在深入探讨策略模式的进阶应用之前，让我们先快速回顾一下这个经典设计模式的基本概念。策略模式属于行为型设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。这种模式让算法的变化独立于使用算法的客户。
策略模式通常由三个核心部分组成：
- Context（上下文）：持有一个策略类的引用，通过接口与策略对象交互
- Strategy（策略接口）：定义所有支持的算法的公共接口
- ConcreteStrategy（具体策略）：实现策略接口的具体算法类
一个典型的策略模式UML类图如下所示：
code复制+----------------+ +-------------------+ +-----------------------+
| Context | | Strategy | | ConcreteStrategyA |
+----------------+ +-------------------+ +-----------------------+
| -strategy:Strategy |<>----| +algorithm():void |<|----| +algorithm():void |
+----------------+ +-------------------+ +-----------------------+
| +-----------------------+
| | ConcreteStrategyB |
| +-----------------------+
|----| +algorithm():void |
+-----------------------+
在C++中，策略模式的基本实现通常如下：
cpp复制// 策略接口
class Strategy {
public:
virtual ~Strategy() = default;
virtual void execute() const = 0;
};
// 具体策略A
class ConcreteStrategyA : public Strategy {
public:
void execute() const override {
std::cout << "Executing Strategy A\n";
}
};
// 具体策略B
class ConcreteStrategyB : public Strategy {
public:
void execute() const override {
std::cout << "Executing Strategy B\n";
}
};
// 上下文
class Context {
private:
std::unique_ptr<Strategy> strategy;
public:
explicit Context(std::unique_ptr<Strategy> strategy)
: strategy(std::move(strategy)) {}
void setStrategy(std::unique_ptr<Strategy> strategy) {
this->strategy = std::move(strategy);
}
void executeStrategy() const {
if(strategy) {
strategy->execute();
}
}
};
提示：在实际项目中，策略接口通常会包含更丰富的业务相关方法，而不仅仅是简单的execute()。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 策略模式的现代C++实现技巧
随着C++11/14/17标准的引入，我们可以用更现代、更简洁的方式实现策略模式。下面介绍几种进阶实现技巧。
2.1 使用std::function替代继承
传统策略模式使用继承和多态来实现策略的切换，但在现代C++中，我们可以使用std::function和lambda表达式来实现更灵活的策略模式：
cpp复制#include <functional>
#include <iostream>
class Context {
private:
std::function<void()> strategy;
public:
explicit Context(std::function<void()> strategy)
: strategy(std::move(strategy)) {}
void setStrategy(std::function<void()> strategy) {
this->strategy = std::move(strategy);
}
void executeStrategy() const {
if(strategy) {
strategy();
}
}
};
int main() {
Context context([](){
std::cout << "Lambda Strategy A\n";
});
context.executeStrategy();
context.setStrategy([](){
std::cout << "Lambda Strategy B\n";
});
context.executeStrategy();
return 0;
}
这种方法的好处是：
- 不需要定义策略接口和具体策略类
- 可以直接在调用处定义策略逻辑
- 更轻量级，避免了虚函数调用的开销
2.2 策略模式与模板的结合
我们可以将策略模式与模板结合，实现编译时策略选择：
cpp复制template<typename Strategy>
class Context {
private:
Strategy strategy;
public:
void executeStrategy() const {
strategy.execute();
}
};
struct StrategyA {
void execute() const {
std::cout << "Template Strategy A\n";
}
};
struct StrategyB {
void execute() const {
std::cout << "Template Strategy B\n";
}
};
int main() {
Context<StrategyA> contextA;
contextA.executeStrategy();
Context<StrategyB> contextB;
contextB.executeStrategy();
return 0;
}
这种方式的优点是：
- 完全消除了运行时多态的开销
- 编译器可以进行更好的优化
- 策略类型在编译期就确定，更安全
缺点是策略不能在运行时动态切换。
2.3 使用变参模板支持多种策略参数
有时候不同的策略可能需要不同的参数，我们可以使用变参模板来支持这种情况：
cpp复制class Strategy {
public:
virtual ~Strategy() = default;
template<typename... Args>
void execute(Args&&... args) {
executeImpl(std::forward<Args>(args)...);
}
private:
virtual void executeImpl() = 0;
// 需要为每种参数组合提供特化
};
// 更通用的方法是使用std::function和std::any
class AdvancedContext {
private:
std::function<void(std::any)> strategy;
std::any contextData;
public:
template<typename T>
void setContextData(T&& data) {
contextData = std::forward<T>(data);
}
void setStrategy(std::function<void(std::any)> strategy) {
this->strategy = std::move(strategy);
}
void executeStrategy() {
if(strategy) {
strategy(contextData);
}
}
};
3. 策略模式在实际项目中的高级应用
策略模式在实际项目中有许多高级应用场景，下面介绍几个典型案例。
3.1 算法选择器
在需要根据不同条件选择不同算法的场景下，策略模式非常有用。例如，在图像处理中，我们可能需要根据图像大小选择不同的处理算法：
cpp复制class ImageProcessor {
public:
enum class ProcessingStrategy {
Fast,
HighQuality,
MemoryEfficient
};
void setStrategy(ProcessingStrategy strategy) {
switch(strategy) {
case ProcessingStrategy::Fast:
currentStrategy = std::make_unique<FastProcessingStrategy>();
break;
case ProcessingStrategy::HighQuality:
currentStrategy = std::make_unique<HighQualityProcessingStrategy>();
break;
case ProcessingStrategy::MemoryEfficient:
currentStrategy = std::make_unique<MemoryEfficientStrategy>();
break;
}
}
void processImage(const Image& image) {
currentStrategy->process(image);
}
private:
std::unique_ptr<ProcessingStrategy> currentStrategy;
};
3.2 支付系统策略
在电商系统中，支付方式的选择是策略模式的经典应用：
cpp复制class PaymentContext {
public:
void setPaymentStrategy(std::unique_ptr<PaymentStrategy> strategy) {
paymentStrategy = std::move(strategy);
}
bool processPayment(double amount) {
return paymentStrategy->pay(amount);
}
private:
std::unique_ptr<PaymentStrategy> paymentStrategy;
};
// 使用示例
PaymentContext context;
context.setPaymentStrategy(std::make_unique<CreditCardPayment>());
context.processPayment(100.0);
context.setPaymentStrategy(std::make_unique<PayPalPayment>());
context.processPayment(50.0);
3.3 游戏AI行为策略
在游戏开发中，NPC的行为可以根据不同情况使用不同的策略：
cpp复制class NPC {
public:
void setBehaviorStrategy(std::unique_ptr<BehaviorStrategy> strategy) {
behaviorStrategy = std::move(strategy);
}
void update() {
behaviorStrategy->execute();
}
private:
std::unique_ptr<BehaviorStrategy> behaviorStrategy;
};
// 使用示例
NPC enemy;
enemy.setBehaviorStrategy(std::make_unique<AggressiveBehavior>());
// 游戏循环中
enemy.update();
// 当玩家获得特殊道具后
enemy.setBehaviorStrategy(std::make_unique<DefensiveBehavior>());
4. 策略模式的性能优化与陷阱规避
在实际使用策略模式时，需要注意一些性能问题和常见陷阱。
4.1 虚函数调用的开销
传统的基于继承的策略模式会使用虚函数，这会带来一定的性能开销。在性能敏感的场合，可以考虑以下优化方法：
- 使用模板策略模式（编译期多态）
- 将小策略函数标记为
inline - 使用
final关键字修饰不需要进一步派生的策略类
cpp复制class FastStrategy final : public Strategy {
public:
void execute() const final override {
// 实现
}
};
4.2 策略对象的生命周期管理
策略对象的管理需要注意内存安全问题：
cpp复制// 不安全的做法
void unsafeUse() {
Strategy* strategy = new ConcreteStrategyA();
Context context(strategy);
// 如果context不负责删除strategy，会导致内存泄漏
}
// 安全的做法 - 使用智能指针
void safeUse() {
auto strategy = std::make_unique<ConcreteStrategyA>();
Context context(std::move(strategy));
// 自动管理内存
}
4.3 策略模式的线程安全性
在多线程环境下使用策略模式需要注意：
- 策略切换的原子性
- 策略对象的线程安全性
cpp复制class ThreadSafeContext {
public:
void setStrategy(std::unique_ptr<Strategy> strategy) {
std::lock_guard<std::mutex> lock(mutex);
currentStrategy = std::move(strategy);
}
void executeStrategy() const {
std::lock_guard<std::mutex> lock(mutex);
if(currentStrategy) {
currentStrategy->execute();
}
}
private:
mutable std::mutex mutex;
std::unique_ptr<Strategy> currentStrategy;
};
4.4 策略膨胀问题
当策略类过多时，会导致代码难以维护。解决方法包括：
- 使用工厂模式管理策略创建
- 将简单策略合并为参数化策略
- 使用策略组合模式
cpp复制// 参数化策略示例
class ParametricStrategy : public Strategy {
public:
explicit ParametricStrategy(int aggressiveness)
: aggressiveness(aggressiveness) {}
void execute() const override {
// 根据aggressiveness参数调整行为
}
private:
int aggressiveness;
};
// 策略组合示例
class CompositeStrategy : public Strategy {
public:
void addStrategy(std::unique_ptr<Strategy> strategy) {
strategies.push_back(std::move(strategy));
}
void execute() const override {
for(const auto& strategy : strategies) {
strategy->execute();
}
}
private:
std::vector<std::unique_ptr<Strategy>> strategies;
};
5. 策略模式与其他设计模式的结合
策略模式可以与其他设计模式结合使用，形成更强大的解决方案。
5.1 策略模式与工厂模式
工厂模式可以帮助我们更好地创建和管理策略对象：
cpp复制class StrategyFactory {
public:
enum class StrategyType {
A,
B,
C
};
static std::unique_ptr<Strategy> create(StrategyType type) {
switch(type) {
case StrategyType::A: return std::make_unique<StrategyA>();
case StrategyType::B: return std::make_unique<StrategyB>();
case StrategyType::C: return std::make_unique<StrategyC>();
default: throw std::invalid_argument("Unknown strategy type");
}
}
};
// 使用示例
auto strategy = StrategyFactory::create(StrategyFactory::StrategyType::A);
Context context(std::move(strategy));
5.2 策略模式与装饰器模式
装饰器模式可以用于动态地为策略添加功能：
cpp复制class StrategyDecorator : public Strategy {
public:
explicit StrategyDecorator(std::unique_ptr<Strategy> strategy)
: wrapped(std::move(strategy)) {}
void execute() const override {
preExecute();
wrapped->execute();
postExecute();
}
protected:
virtual void preExecute() const = 0;
virtual void postExecute() const = 0;
private:
std::unique_ptr<Strategy> wrapped;
};
class LoggingDecorator : public StrategyDecorator {
public:
using StrategyDecorator::StrategyDecorator;
protected:
void preExecute() const override {
std::cout << "Before executing strategy\n";
}
void postExecute() const override {
std::cout << "After executing strategy\n";
}
};
5.3 策略模式与状态模式
策略模式和状态模式看起来很相似，但它们有不同的用途：
- 策略模式：客户端主动选择算法
- 状态模式：对象内部状态自动转换导致行为改变
cpp复制// 状态模式示例
class State {
public:
virtual ~State() = default;
virtual void handle(Context& context) = 0;
};
class Context {
public:
void setState(std::unique_ptr<State> state) {
currentState = std::move(state);
}
void request() {
currentState->handle(*this);
}
private:
std::unique_ptr<State> currentState;
};
5.4 策略模式与命令模式
命令模式将操作封装为对象，与策略模式有相似之处：
- 策略模式：关注算法的互换
- 命令模式：关注操作的封装和执行时机
cpp复制// 命令模式示例
class Command {
public:
virtual ~Command() = default;
virtual void execute() = 0;
};
class Invoker {
public:
void setCommand(std::unique_ptr<Command> cmd) {
command = std::move(cmd);
}
void executeCommand() {
if(command) {
command->execute();
}
}
private:
std::unique_ptr<Command> command;
};
6. C++20/23中的策略模式新可能
随着C++标准的演进，策略模式有了更多现代实现方式。
6.1 使用概念(Concepts)约束策略类型
C++20的概念(Concepts)可以让我们更好地约束策略类型：
cpp复制template<typename T>
concept StrategyConcept = requires(T t) {
{ t.execute() } -> std::same_as<void>;
};
template<StrategyConcept Strategy>
class ModernContext {
public:
void executeStrategy() const {
strategy.execute();
}
private:
Strategy strategy;
};
6.2 使用协程(Coroutines)实现异步策略
C++20的协程可以用于实现异步策略：
cpp复制struct AsyncStrategy {
struct promise_type {
AsyncStrategy get_return_object() { return {}; }
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {}
};
std::future<void> executeAsync() {
co_await std::suspend_always{};
// 异步执行策略
}
};
6.3 使用范围(Ranges)实现数据处理策略
C++20的范围库可以用于实现数据处理策略：
cpp复制class DataProcessingStrategy {
public:
virtual std::ranges::range auto process(std::ranges::range auto input) = 0;
};
class TransformStrategy : public DataProcessingStrategy {
public:
std::ranges::range auto process(std::ranges::range auto input) override {
return input | std::views::transform([](auto x) { return x * 2; });
}
};
6.4 使用模块(Modules)组织策略代码
C++20的模块系统可以更好地组织策略代码：
cpp复制// strategy.ixx
export module strategy;
export {
class Strategy {
public:
virtual ~Strategy() = default;
virtual void execute() = 0;
};
class Context {
public:
void setStrategy(std::unique_ptr<Strategy> strategy);
void executeStrategy() const;
private:
std::unique_ptr<Strategy> strategy;
};
}
// main.cpp
import strategy;
class MyStrategy : public Strategy {
void execute() override {
// 实现
}
};
int main() {
Context context;
context.setStrategy(std::make_unique<MyStrategy>());
context.executeStrategy();
}
7. 策略模式在大型项目中的架构实践
在大型项目中，策略模式的应用需要考虑更多架构层面的问题。
7.1 策略的依赖注入
使用依赖注入框架管理策略对象：
cpp复制// 使用Boost.DI示例
#include <boost/di.hpp>
namespace di = boost::di;
class Strategy {
public:
virtual ~Strategy() = default;
virtual void execute() = 0;
};
class StrategyA : public Strategy {
public:
void execute() override {
std::cout << "Strategy A\n";
}
};
class Context {
public:
explicit Context(std::shared_ptr<Strategy> strategy)
: strategy(std::move(strategy)) {}
void executeStrategy() {
strategy->execute();
}
private:
std::shared_ptr<Strategy> strategy;
};
int main() {
auto injector = di::make_injector(
di::bind<Strategy>().to<StrategyA>()
);
auto context = injector.create<Context>();
context.executeStrategy();
return 0;
}
7.2 策略的插件化架构
实现可动态加载的策略插件：
cpp复制// 插件接口
extern "C" {
Strategy* createStrategy();
void destroyStrategy(Strategy*);
}
// 主程序
class PluginManager {
public:
void loadPlugin(const std::string& path) {
auto handle = dlopen(path.c_str(), RTLD_LAZY);
if(!handle) throw std::runtime_error(dlerror());
auto create = reinterpret_cast<Strategy*(*)()>(dlsym(handle, "createStrategy"));
plugins.push_back({handle, create()});
}
std::vector<std::unique_ptr<Strategy>> getAllStrategies() {
std::vector<std::unique_ptr<Strategy>> result;
for(auto& plugin : plugins) {
result.emplace_back(plugin.strategy);
}
return result;
}
private:
struct Plugin {
void* handle;
Strategy* strategy;
};
std::vector<Plugin> plugins;
};
7.3 策略的配置化
从配置文件动态加载策略：
config复制# strategies.conf
[default]
strategy=fast
[strategies]
fast=FastProcessingStrategy
quality=HighQualityProcessingStrategy
cpp复制class StrategyConfigurator {
public:
std::unique_ptr<Strategy> createFromConfig(const Config& config) {
auto type = config.get("strategies", config.get("default", "strategy"));
if(type == "fast") return std::make_unique<FastProcessingStrategy>();
if(type == "quality") return std::make_unique<HighQualityProcessingStrategy>();
throw std::runtime_error("Unknown strategy type");
}
};
7.4 策略的版本控制与热更新
实现可热更新的策略：
cpp复制class HotSwappableStrategy : public Strategy {
public:
void updateImplementation(std::unique_ptr<Strategy> newImpl) {
std::lock_guard<std::mutex> lock(mutex);
implementation = std::move(newImpl);
}
void execute() override {
std::lock_guard<std::mutex> lock(mutex);
implementation->execute();
}
private:
mutable std::mutex mutex;
std::unique_ptr<Strategy> implementation;
};
8. 策略模式的测试与调试技巧
策略模式的测试有其特殊性，需要特别注意以下几点。
8.1 策略接口的单元测试
使用模拟对象测试策略接口：
cpp复制class MockStrategy : public Strategy {
public:
MOCK_METHOD(void, execute, (), (override));
};
TEST(ContextTest, ExecuteStrategy) {
MockStrategy mock;
Context context(&mock);
EXPECT_CALL(mock, execute()).Times(1);
context.executeStrategy();
}
8.2 策略组合的集成测试
测试多个策略的组合效果：
cpp复制TEST(StrategyCombinationTest, OrderExecution) {
TestingStrategy strategy1;
TestingStrategy strategy2;
CompositeStrategy composite;
composite.addStrategy(std::make_unique<TestingStrategy>(strategy1));
composite.addStrategy(std::make_unique<TestingStrategy>(strategy2));
composite.execute();
ASSERT_TRUE(strategy1.executedBefore(strategy2));
}
8.3 策略性能的基准测试
使用Google Benchmark测试不同策略的性能：
cpp复制static void BM_FastStrategy(benchmark::State& state) {
FastStrategy strategy;
for(auto _ : state) {
strategy.execute();
}
}
BENCHMARK(BM_FastStrategy);
static void BM_QualityStrategy(benchmark::State& state) {
QualityStrategy strategy;
for(auto _ : state) {
strategy.execute();
}
}
BENCHMARK(BM_QualityStrategy);
8.4 策略选择的决策测试
测试策略选择逻辑：
cpp复制TEST(StrategySelectorTest, SelectsCorrectStrategy) {
StrategySelector selector;
auto smallDataStrategy = selector.selectStrategyFor(DataSize::Small);
ASSERT_TRUE(dynamic_cast<FastStrategy*>(smallDataStrategy.get()));
auto largeDataStrategy = selector.selectStrategyFor(DataSize::Large);
ASSERT_TRUE(dynamic_cast<MemoryEfficientStrategy*>(largeDataStrategy.get()));
}
8.5 策略的调试技巧
调试策略模式时的一些技巧：
- 为策略添加唯一标识符，便于跟踪
- 实现策略的序列化/反序列化，用于重现问题
- 记录策略切换的历史
- 使用装饰器模式添加调试日志
cpp复制class DebuggableStrategy : public Strategy {
public:
explicit DebuggableStrategy(std::unique_ptr<Strategy> strategy)
: strategy(std::move(strategy)) {}
void execute() override {
std::cout << "Executing strategy: " << typeid(*strategy).name() << "\n";
auto start = std::chrono::high_resolution_clock::now();
strategy->execute();
auto end = std::chrono::high_resolution_clock::now();
std::cout << "Execution took: "
<< std::chrono::duration_cast<std::chrono::microseconds>(end - start).count()
<< "μs\n";
}
private:
std::unique_ptr<Strategy> strategy;
};
9. 策略模式在不同领域的变体与实践
策略模式在不同领域有各种变体实现，下面介绍几种常见场景。
9.1 游戏开发中的策略模式
在游戏开发中，策略模式常用于AI行为控制：
cpp复制class AICharacter {
public:
void setMovementStrategy(std::unique_ptr<MovementStrategy> strategy) {
movementStrategy = std::move(strategy);
}
void setAttackStrategy(std::unique_ptr<AttackStrategy> strategy) {
attackStrategy = std::move(strategy);
}
void update() {
movementStrategy->move();
if(enemyInRange()) {
attackStrategy->attack();
}
}
private:
std::unique_ptr<MovementStrategy> movementStrategy;
std::unique_ptr<AttackStrategy> attackStrategy;
};
9.2 金融领域的策略模式
在量化交易中，不同的交易策略可以灵活切换：
cpp复制class TradingEngine {
public:
void setPricingStrategy(std::unique_ptr<PricingStrategy> strategy) {
pricingStrategy = std::move(strategy);
}
void setExecutionStrategy(std::unique_ptr<ExecutionStrategy> strategy) {
executionStrategy = std::move(strategy);
}
void processOrder(const Order& order) {
auto price = pricingStrategy->calculatePrice(order);
executionStrategy->executeOrder(order, price);
}
private:
std::unique_ptr<PricingStrategy> pricingStrategy;
std::unique_ptr<ExecutionStrategy> executionStrategy;
};
9.3 嵌入式系统的策略模式
在资源受限的嵌入式系统中，策略模式的轻量级实现：
cpp复制// 不使用动态多态，节省内存
class SensorProcessor {
public:
using ProcessingFn = void(*)(SensorData&);
void setProcessingStrategy(ProcessingFn fn) {
processFn = fn;
}
void process(SensorData& data) {
if(processFn) {
processFn(data);
}
}
private:
ProcessingFn processFn = nullptr;
};
// 策略函数
void normalizeData(SensorData& data) {
// 实现
}
void filterNoise(SensorData& data) {
// 实现
}
9.4 机器学习中的策略模式
在机器学习流水线中，不同的预处理/训练策略：
cpp复制class MLPipeline {
public:
void setPreprocessingStrategy(std::unique_ptr<PreprocessingStrategy> strategy) {
preprocessor = std::move(strategy);
}
void setTrainingStrategy(std::unique_ptr<TrainingStrategy> strategy) {
trainer = std::move(strategy);
}
Model train(Dataset& data) {
auto processed = preprocessor->process(data);
return trainer->train(processed);
}
private:
std::unique_ptr<PreprocessingStrategy> preprocessor;
std::unique_ptr<TrainingStrategy> trainer;
};
10. 从策略模式到策略引擎的演进
对于复杂的策略应用，可以进一步发展为策略引擎。
10.1 策略引擎的基本架构
一个完整的策略引擎可能包含以下组件：
cpp复制class StrategyEngine {
public:
void registerStrategy(std::string name, std::unique_ptr<Strategy> strategy) {
strategies.emplace(std::move(name), std::move(strategy));
}
void executeStrategy(const std::string& name) {
if(auto it = strategies.find(name); it != strategies.end()) {
it->second->execute();
}
}
void setStrategySelector(std::unique_ptr<StrategySelector> selector) {
this->selector = std::move(selector);
}
void executeBestStrategy(const ContextData& data) {
auto name = selector->selectStrategy(data);
executeStrategy(name);
}
private:
std::unordered_map<std::string, std::unique_ptr<Strategy>> strategies;
std::unique_ptr<StrategySelector> selector;
};
10.2 策略的元数据管理
为策略添加元数据描述：
cpp复制struct StrategyMeta {
std::string name;
std::string description;
std::vector<std::string> tags;
int priority = 0;
};
class StrategyWithMeta : public Strategy {
public:
StrategyWithMeta(std::unique_ptr<Strategy> strategy, StrategyMeta meta)
: strategy(std::move(strategy)), meta(std::move(meta)) {}
void execute() override {
strategy->execute();
}
const StrategyMeta& getMeta() const { return meta; }
private:
std::unique_ptr<Strategy> strategy;
StrategyMeta meta;
};
10.3 策略的依赖管理
处理策略之间的依赖关系：
cpp复制class DependentStrategy : public Strategy {
public:
DependentStrategy(std::unique_ptr<Strategy> main,
std::vector<std::unique_ptr<Strategy>> dependencies)
: main(std::move(main)), dependencies(std::move(dependencies)) {}
void execute() override {
for(auto& dep : dependencies) {
dep->execute();
}
main->execute();
}
private:
std::unique_ptr<Strategy> main;
std::vector<std::unique_ptr<Strategy>> dependencies;
};
10.4 策略的评估与优化
自动评估策略效果并优化：
cpp复制class StrategyEvaluator {
public:
struct EvaluationResult {
double score;
std::chrono::milliseconds duration;
// 其他指标...
};
EvaluationResult evaluate(Strategy& strategy) {
auto start = std::chrono::high_resolution_clock::now();
strategy.execute();
auto end = std::chrono::high_resolution_clock::now();
return {
calculateScore(),
std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
};
}
};
class AutoOptimizingStrategyEngine : public StrategyEngine {
public:
void optimizeStrategies() {
for(auto& [name, strategy] : strategies) {
auto result = evaluator.evaluate(*strategy);
if(result.score < threshold) {
// 触发策略优化或替换
}
}
}
private:
StrategyEvaluator evaluator;
double threshold = 0.8;
};
在实际项目中，策略模式的这些进阶应用可以显著提高代码的灵活性和可维护性。根据具体需求选择合适的实现方式，并注意避免过度设计。策略模式真正的威力在于它能够让算法的变化独立于使用算法的客户，从而使系统更加符合开闭原则。