C++策略工厂模式与运行时选择设计

策略工厂模式是将策略模式与工厂模式结合，通过封装算法并按需创建实例的架构设计。其核心优势包括：1.解耦调用方与具体类；2.扩展新策略无需修改代码；3.集中管理创建逻辑。实现结构分为四步：1.定义策略接口；2.实现具体策略类；3.构建工厂类处理创建逻辑；4.注册策略供运行时选择。运行时动态选择策略可通过读取外部输入（如命令行、配置文件）获取标识符，并由工厂返回对应实例，同时需支持灵活输入来源、统一标识格式及错误处理机制。实际开发中建议优化点包括：宏或模板自动注册策略、支持别名、设置默认策略、结合依赖注入框架以及传递初始化参数。

在C++项目中，策略工厂模式结合运行时策略选择，能构建出一个灵活、可扩展的架构。核心在于将策略的创建和使用解耦，并通过配置或输入动态决定使用哪个策略。这种设计不仅提升了代码的可维护性，也方便后期新增策略而无需修改已有逻辑。

什么是策略工厂模式？

策略模式允许你定义一系列算法或行为，并将它们封装成独立类，使得它们可以互换使用。工厂模式则用于集中管理这些策略对象的创建过程。两者结合后，客户端只需提供标识（比如字符串、枚举等），就能获取对应的策略实例。

这种方式的优势在于：

• 解耦：调用方不需要知道具体策略类名，只依赖接口。
• 易扩展：新增策略只需要添加新类和注册逻辑，不破坏开闭原则。
• 统一管理：策略创建逻辑集中在工厂中，便于维护和测试。

如何实现策略工厂的基本结构？

要实现策略工厂，通常需要以下几个部分：

• 一个公共接口（基类）用于定义策略行为
• 多个具体策略类继承该接口
• 一个工厂类用于根据参数返回对应的策略实例

例如，定义一个简单的策略接口：

class Strategy {
public:
    virtual void execute() = 0;
    virtual ~Strategy() = default;
};

然后定义两个具体策略：

class StrategyA : public Strategy {
public:
    void execute() override {
        std::cout << "Executing Strategy A\n";
    }
};

class StrategyB : public Strategy {
public:
    void execute() override {
        std::cout << "Executing Strategy B\n";
    }
};

接着是策略工厂：

class StrategyFactory {
public:
    using StrategyCreator = std::function;

    static StrategyFactory& instance() {
        static StrategyFactory factory;
        return factory;
    }

    void registerStrategy(const std::string& name, StrategyCreator creator) {
        creators_[name] = creator;
    }

    Strategy* createStrategy(const std::string& name) {
        auto it = creators_.find(name);
        if (it != creators_.end()) {
            return it->second();
        }
        return nullptr;
    }

private:
    std::unordered_map creators_;
};

最后，在程序启动时注册策略：

namespace {
    Strategy* createStrategyA() { return new StrategyA(); }
    Strategy* createStrategyB() { return new StrategyB(); }

    struct RegisterStrategies {
        RegisterStrategies() {
            StrategyFactory::instance().registerStrategy("A", createStrategyA);
            StrategyFactory::instance().registerStrategy("B", createStrategyB);
        }
    } registrar;
}

这样就可以在运行时根据传入的字符串选择不同策略了。

如何支持运行时动态选择策略？

为了实现运行时选择策略，关键是让系统能够从外部输入（如命令行参数、配置文件、网络请求等）读取策略标识，并传递给工厂进行创建。

比如，从命令行参数中读取策略名称：

int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cerr << "Usage: program \n";
        return 1;
    }

    std::string strategyName = argv[1];
    Strategy* strategy = StrategyFactory::instance().createStrategy(strategyName);

    if (!strategy) {
        std::cerr << "Unknown strategy: " << strategyName << "\n";
        return 1;
    }

    strategy->execute();
    delete strategy;

    return 0;
}

运行时选择的关键点包括：

• 输入来源灵活：可以是用户输入、配置文件、数据库、远程服务等
• 标识符格式统一：建议采用字符串或枚举作为策略标识
• 错误处理机制：策略不存在时要有明确提示或默认回退策略

如果你希望更健壮一些，还可以引入智能指针来管理内存，或者使用单例策略缓存来提升性能。

实际开发中的优化建议

在实际项目中，可以考虑以下几点来增强策略工厂的灵活性和可用性：

• 使用宏或模板自动注册策略，避免手动写注册代码
• 支持策略别名，比如“fast”对应“StrategyFast”
• 增加默认策略，当未找到匹配项时返回基础实现
• 结合依赖注入框架，减少对全局单例的依赖
• 策略类本身也可以有配置参数，由工厂传入初始化

比如，你可以定义一个宏来简化注册流程：

#define REGISTER_STRATEGY(name, className) \
    struct className##Registrar { \
        className##Registrar() { \
            StrategyFactory::instance().registerStrategy(name, []() -> Strategy* { return new className(); }); \
        } \
    }; \
    static className##Registrar global_##className##_registrar;

然后在每个策略类的实现文件中加上：

REGISTER_STRATEGY("A", StrategyA)

这样就实现了自动化注册，降低了出错风险。

基本上就这些。只要把策略抽象清楚、工厂实现到位、运行时输入解析好，就能搭建出一个灵活又稳定的策略执行系统。