1. 工厂模式的核心概念与基础实现

工厂模式是面向对象设计中最为经典的模式之一，它通过将对象的创建过程封装到一个专门的类中，实现了创建逻辑与业务逻辑的解耦。在C++中，工厂模式的应用尤为广泛，特别是在需要管理复杂对象创建过程的场景下。

1.1 简单工厂模式实现

简单工厂模式是最基础的工厂实现形式，它通过一个静态方法根据输入参数决定创建哪种具体产品。下面是一个典型的C++实现示例：

class Product { public: virtual ~Product() {} virtual void operation() = 0; }; class ConcreteProductA : public Product { public: void operation() override { std::cout << "ConcreteProductA operation" << std::endl; } }; class ConcreteProductB : public Product { public: void operation() override { std::cout << "ConcreteProductB operation" << std::endl; } }; class SimpleFactory { public: static Product* createProduct(const std::string& type) { if (type == "A") { return new ConcreteProductA(); } else if (type == "B") { return new ConcreteProductB(); } return nullptr; } };

这种实现方式的优点在于简单直接，但缺点也很明显：当需要新增产品类型时，必须修改工厂类的代码，这违反了开闭原则。

1.2 工厂方法模式进阶

工厂方法模式通过定义一个创建对象的接口，但让子类决定实例化哪个类，解决了简单工厂的扩展性问题：

class Creator { public: virtual ~Creator() {} virtual Product* factoryMethod() = 0; void someOperation() { Product* p = factoryMethod(); p->operation(); delete p; } }; class ConcreteCreatorA : public Creator { public: Product* factoryMethod() override { return new ConcreteProductA(); } }; class ConcreteCreatorB : public Creator { public: Product* factoryMethod() override { return new ConcreteProductB(); } };

在实际项目中，我经常使用工厂方法模式来处理插件系统的初始化。每个插件可以定义自己的创建器，主程序只需要知道Creator接口，不需要了解具体插件的实现细节。

提示：工厂方法模式特别适合框架开发，框架定义创建接口，具体实现由应用代码提供。

2. 抽象工厂模式与多产品族管理

2.1 抽象工厂模式实现

当系统需要创建多个相关或依赖的对象时，抽象工厂模式提供了更好的解决方案。它定义了一个接口用于创建相关或依赖对象的家族，而不需要明确指定具体类：

class AbstractProductA { public: virtual ~AbstractProductA() {} virtual void operationA() = 0; }; class AbstractProductB { public: virtual ~AbstractProductB() {} virtual void operationB() = 0; }; class ConcreteProductA1 : public AbstractProductA { public: void operationA() override { std::cout << "ConcreteProductA1 operation" << std::endl; } }; class ConcreteProductB1 : public AbstractProductB { public: void operationB() override { std::cout << "ConcreteProductB1 operation" << std::endl; } }; class AbstractFactory { public: virtual AbstractProductA* createProductA() = 0; virtual AbstractProductB* createProductB() = 0; }; class ConcreteFactory1 : public AbstractFactory { public: AbstractProductA* createProductA() override { return new ConcreteProductA1(); } AbstractProductB* createProductB() override { return new ConcreteProductB1(); } };

2.2 跨平台UI开发实战案例

在跨平台UI开发中，抽象工厂模式大放异彩。我们可以为每个平台（Windows、Mac、Linux）实现一个具体工厂，每个工厂创建对应平台的UI组件：

class Button { public: virtual void render() = 0; }; class WindowsButton : public Button { public: void render() override { std::cout << "Rendering Windows style button" << std::endl; } }; class MacButton : public Button { public: void render() override { std::cout << "Rendering Mac style button" << std::endl; } }; class UIFactory { public: virtual Button* createButton() = 0; }; class WindowsUIFactory : public UIFactory { public: Button* createButton() override { return new WindowsButton(); } }; class MacUIFactory : public UIFactory { public: Button* createButton() override { return new MacButton(); } };

在实际项目中，我们通常会结合运行时环境检测来自动选择合适的具体工厂：

UIFactory* createUIFactory() { #ifdef _WIN32 return new WindowsUIFactory(); #elif __APPLE__ return new MacUIFactory(); #else return new LinuxUIFactory(); #endif }

3. 模板工厂与编译时多态

3.1 基于模板的静态工厂

C++的模板特性允许我们在编译期实现工厂模式，这种方式完全消除了运行时开销：

template <typename T> class ProductCreator { public: static T* create() { return new T(); } }; // 使用示例 auto product = ProductCreator<ConcreteProductA>::create();

这种实现方式特别适合性能敏感的场景，因为所有类型解析都在编译期完成。我在一个高频交易系统中使用这种模式，成功将对象创建时间从微秒级降低到纳秒级。

3.2 策略工厂模式

结合策略模式和工厂模式，我们可以创建更加灵活的对象创建机制：

template <typename ProductType> class CreationStrategy { public: virtual ProductType* create() = 0; }; template <typename ProductType> class NewOperatorStrategy : public CreationStrategy<ProductType> { public: ProductType* create() override { return new ProductType(); } }; template <typename ProductType, typename Strategy = NewOperatorStrategy<ProductType>> class StrategyFactory { public: ProductType* createProduct() { Strategy strategy; return strategy.create(); } };

这种设计允许我们在不修改工厂代码的情况下，通过更换策略来改变对象的创建方式。例如，可以实现一个PoolStrategy来使用对象池而非直接new操作。

4. 现代C++中的工厂模式演进

4.1 基于智能指针的工厂

现代C++推荐使用智能指针管理资源所有权，工厂模式也需要相应调整：

class SmartFactory { public: virtual std::unique_ptr<Product> createProduct() = 0; }; class ConcreteSmartFactory : public SmartFactory { public: std::unique_ptr<Product> createProduct() override { return std::make_unique<ConcreteProductA>(); } };

在实际项目中，我发现这种实现方式显著减少了内存泄漏问题。特别是在异常安全方面，智能指针保证了即使创建过程中发生异常，资源也能被正确释放。

4.2 基于lambda的工厂注册

C++11引入的lambda表达式为工厂模式带来了新的实现方式。我们可以创建一个通用的工厂类，允许运行时注册产品创建函数：

class LambdaFactory { public: using CreatorFunc = std::function<std::unique_ptr<Product>()>; void registerCreator(const std::string& type, CreatorFunc creator) { creators_[type] = creator; } std::unique_ptr<Product> create(const std::string& type) { auto it = creators_.find(type); if (it != creators_.end()) { return it->second(); } return nullptr; } private: std::unordered_map<std::string, CreatorFunc> creators_; }; // 使用示例 LambdaFactory factory; factory.registerCreator("A", []() { return std::make_unique<ConcreteProductA>(); }); factory.registerCreator("B", []() { return std::make_unique<ConcreteProductB>(); }); auto product = factory.create("A");

这种实现方式在插件系统中特别有用，每个插件可以在初始化时向工厂注册自己的创建函数。

4.3 基于variant的异构工厂

C++17引入的std::variant允许我们创建可以返回多种类型对象的工厂：

using ProductVariant = std::variant<ConcreteProductA, ConcreteProductB>; class VariantFactory { public: ProductVariant createProduct(const std::string& type) { if (type == "A") { return ConcreteProductA(); } else if (type == "B") { return ConcreteProductB(); } throw std::runtime_error("Unknown product type"); } };

这种模式在需要处理多种相关类型但又不希望通过继承来抽象的场合特别有用。我在一个游戏引擎中使用这种模式来处理不同类型的资源加载，代码比传统的继承方案简洁许多。

注意：使用variant时要注意类型安全，确保访问variant时处理了所有可能的类型。