C++工厂模式实践：从基础到高级应用解析

1. 工厂模式的核心价值与常见痛点

工厂模式作为创建型设计模式的代表，在C++开发中扮演着重要角色。我第一次接触工厂模式是在一个跨平台渲染引擎项目中，当时需要根据不同的图形API（OpenGL/Vulkan/DirectX）创建对应的渲染器实例。直接使用new关键字会导致客户端代码与具体实现类高度耦合，而工厂模式的引入完美解决了这个问题。

工厂模式的核心价值主要体现在三个方面：

1. 解耦客户端代码与具体产品类的依赖关系
2. 集中管理对象创建的复杂逻辑
3. 提供统一的扩展接口

但在实际工程实践中，标准的工厂模式往往会遇到几个典型问题：

• 每新增一个产品类就需要修改工厂类，违反开闭原则
• 简单对象的创建过程显得过于重量级
• 难以应对多层次的产品族创建需求

正是这些痛点催生了工厂模式的多种变体。下面我们通过一个实际案例来说明：假设我们正在开发一个跨平台UI框架，需要创建不同风格（Material Design/Cupertino）的按钮（Button）、文本框（TextBox）等控件。如果使用简单工厂模式，代码很快就会变得难以维护。

2. 静态工厂方法的轻量级实践

静态工厂方法是最简单的工厂模式变体，它通过类的静态成员函数来封装对象创建逻辑。与标准工厂模式相比，它不需要创建单独的工厂类，更适合简单场景。

cpp复制class Widget {
public:
    static std::unique_ptr<Widget> createButton(WidgetStyle style) {
        switch(style) {
            case Material: return std::make_unique<MaterialButton>();
            case Cupertino: return std::make_unique<CupertinoButton>();
            default: throw std::invalid_argument("Unknown style");
        }
    }
    
    virtual void render() = 0;
    virtual ~Widget() = default;
};

这种方式的优势在于：

• 实现简单，不需要额外类层级
• 适合产品类型较少且稳定的场景
• 天然支持单例等特殊创建逻辑

我在一个嵌入式HMI项目中就采用了这种模式，为不同的硬件平台（STM32/NXP）创建对应的驱动适配器。但要注意几个陷阱：

1. 静态方法无法被继承，扩展性受限
2. 当产品类型增多时，switch-case会变得臃肿
3. 创建逻辑与产品类耦合，违反单一职责原则

提示：当产品类型超过5种时，建议考虑更复杂的工厂实现，避免静态方法膨胀。

3. 工厂方法模式的运行时动态扩展

工厂方法模式通过将对象创建延迟到子类，解决了静态工厂的扩展性问题。这是GoF经典设计模式中最正统的实现方式。

cpp复制class WidgetFactory {
public:
    virtual std::unique_ptr<Button> createButton() = 0;
    virtual std::unique_ptr<TextBox> createTextBox() = 0;
    virtual ~WidgetFactory() = default;
};

class MaterialFactory : public WidgetFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<MaterialButton>();
    }
    
    std::unique_ptr<TextBox> createTextBox() override {
        return std::make_unique<MaterialTextBox>();
    }
};

这种模式的关键特点：

• 每个产品族对应一个具体工厂类
• 新增产品族不影响现有代码
• 创建逻辑分散在各子类中

在一个电商平台的支付模块开发中，我使用工厂方法为不同支付渠道（支付宝/微信/银联）创建对应的处理器。实际应用中需要注意：

1. 工厂类与产品类的平行层级要保持一致
2. 考虑使用模板方法模式消除重复创建逻辑
3. 工厂对象的生命周期管理很重要

4. 抽象工厂模式处理产品族创建

当系统需要创建多个相关联的产品对象时，抽象工厂模式比简单工厂方法更合适。它能保证创建的产品对象相互兼容。

cpp复制class ThemeFactory {
public:
    virtual std::unique_ptr<ScrollBar> createScrollBar() = ;
    virtual std::unique_ptr<Window> createWindow() = ;
    virtual ~ThemeFactory() = default;
};

class DarkThemeFactory : public ThemeFactory {
public:
    std::unique_ptr<ScrollBar> createScrollBar() override {
        return std::make_unique<DarkScrollBar>();
    }
    
    std::unique_ptr<Window> createWindow() override {
        return std::make_unique<DarkWindow>();
    }
};

在我的一个桌面应用主题系统实现中，抽象工厂确保了所有UI组件风格一致。几个实践经验：

1. 产品族定义要稳定，频繁变更会导致工厂接口不稳定
2. 可以使用惰性创建策略优化性能
3. 考虑结合原型模式减少子类数量

5. 模板工厂：编译期多态的威力

C++的模板元编程能力可以创造出更灵活的工厂实现。模板工厂在编译期确定具体类型，完全消除运行时开销。

cpp复制template <typename T>
class GenericFactory {
public:
    template <typename... Args>
    static auto create(Args&&... args) {
        return std::make_unique<T>(std::forward<Args>(args)...);
    }
};

// 使用示例
auto button = GenericFactory<MaterialButton>::create();

这种模式特别适合：

• 性能敏感的嵌入式系统
• 类型系统丰富的场景
• 需要极致编译时检查的项目

在一个高频交易系统中，我使用模板工厂创建不同的订单处理器，完全消除了虚函数调用开销。需要注意：

1. 类型必须在编译期可知
2. 错误信息可能难以理解
3. 调试难度相对较大

6. 注册式工厂的动态扩展能力

注册式工厂通过运行时类型注册机制，实现了真正的开闭原则。这是我个人最推荐的工厂模式变体。

cpp复制class WidgetFactory {
public:
    using Creator = std::function<std::unique_ptr<Widget>()>;
    
    static void registerCreator(const std::string& type, Creator creator) {
        registry()[type] = creator;
    }
    
    static std::unique_ptr<Widget> create(const std::string& type) {
        auto it = registry().find(type);
        if (it != registry().end()) {
            return it->second();
        }
        return nullptr;
    }

private:
    static std::map<std::string, Creator>& registry() {
        static std::map<std::string, Creator> instance;
        return instance;
    }
};

// 注册示例
WidgetFactory::registerCreator("MaterialButton", [] {
    return std::make_unique<MaterialButton>();
});

这种模式的强大之处在于：

1. 新增类型无需修改工厂代码
2. 支持插件式架构
3. 注册逻辑可以分散在各处

在一个可视化编辑器中，我使用注册式工厂实现了第三方控件扩展。关键经验：

1. 注意注册时机的控制（静态初始化顺序问题）
2. 考虑线程安全性
3. 可以结合元编程自动注册

7. 多态工厂与对象池的结合实践

在高性能场景下，工厂模式可以与对象池技术结合，既保持接口统一性又提升性能。

cpp复制class WidgetPool {
public:
    template <typename T>
    void registerType(int initialCount = 10) {
        pools_[typeid(T).name()] = std::make_unique<ObjectPool<T>>(initialCount);
    }
    
    template <typename T>
    std::shared_ptr<T> acquire() {
        auto it = pools_.find(typeid(T).name());
        if (it != pools_.end()) {
            return std::static_pointer_cast<T>(it->second->acquire());
        }
        return nullptr;
    }

private:
    std::unordered_map<std::string, std::unique_ptr<BasePool>> pools_;
};

这种混合模式在游戏开发中特别有用，我在一个粒子系统实现中就采用了这种方案。注意事项：

1. 对象状态重置要彻底
2. 考虑引入弱引用避免内存泄漏
3. 线程安全需要特别处理

8. 现代C++下的工厂模式演进

C++11/14/17的新特性为工厂模式带来了新的实现方式。比如使用变参模板和完美转发：

cpp复制template <typename Base, typename... Args>
class NewFactory {
public:
    template <typename T>
    static void registerType(const std::string& key) {
        creators_[key] = [](Args... args) {
            return std::make_unique<T>(std::forward<Args>(args)...);
        };
    }
    
    static std::unique_ptr<Base> create(const std::string& key, Args... args) {
        return creators_[key](std::forward<Args>(args)...);
    }

private:
    static std::map<std::string, std::function<std::unique_ptr<Base>(Args...)>>& creators_() {
        static std::map<std::string, std::function<std::unique_ptr<Base>(Args...)>> instance;
        return instance;
    }
};

这种现代实现方式：

1. 支持任意构造函数参数
2. 类型安全更好
3. 代码更简洁

在开发一个网络通信库时，这种模式让我可以灵活创建不同类型的协议处理器。特别适合：

1. 依赖注入框架
2. 插件系统
3. 需要复杂初始化的对象

工厂模式看似简单，但在实际工程中有着丰富的应用场景和变化形式。选择哪种变体，需要根据项目的具体需求、团队习惯和性能要求来决定。经过多个项目的实践，我发现没有放之四海皆准的最佳实践，只有最适合当前场景的解决方案。