C++工厂模式详解：从原理到实战应用

1. 工厂模式概述与核心价值

工厂模式作为创建型设计模式的代表，在C++开发中扮演着至关重要的角色。我第一次接触工厂模式是在开发一个跨平台日志系统时，当时需要根据不同平台（Windows/Linux）创建不同的日志处理器，正是工厂模式帮我优雅地解决了这个问题。

工厂模式的核心价值在于解耦对象的创建与使用。想象一下你去餐厅点餐：作为顾客（客户端），你只需要告诉服务员（工厂）想要什么菜品（产品），而不需要关心这道菜是在哪个灶台、由哪位厨师制作的。这种分离带来的好处是显而易见的：

1. 降低耦合度：客户端代码不需要包含各种具体类的初始化逻辑
2. 提高可维护性：产品创建逻辑集中管理，修改时只需调整工厂类
3. 增强扩展性：新增产品类型时，对现有代码影响最小化

在C++中实现工厂模式时，我们通常会遇到三种变体：简单工厂、工厂方法和抽象工厂。每种变体都有其特定的应用场景和实现方式，接下来我将结合具体案例详细分析它们的区别与实现要点。

2. 简单工厂模式深度解析

2.1 模式结构与实现原理

简单工厂模式（Simple Factory）是最基础的工厂实现，虽然不属于GoF 23种经典设计模式，但在实际开发中应用非常广泛。它的核心结构包含三个角色：

1. 工厂类（Factory）：负责创建所有产品对象的静态方法
2. 抽象产品（Product）：定义产品的公共接口
3. 具体产品（ConcreteProduct）：实现抽象产品接口的具体类

让我们通过一个更贴近实际开发的例子来理解这个模式。假设我们正在开发一个图形编辑器，需要创建不同类型的图形对象：

cpp复制// 抽象产品：图形
class Shape {
public:
    virtual ~Shape() = default;
    virtual void draw() const = 0;
    virtual double area() const = 0;
};

// 具体产品：圆形
class Circle : public Shape {
    double radius;
public:
    explicit Circle(double r) : radius(r) {}
    void draw() const override {
        std::cout << "绘制圆形，半径: " << radius << std::endl;
    }
    double area() const override {
        return 3.14159 * radius * radius;
    }
};

// 具体产品：矩形
class Rectangle : public Shape {
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    void draw() const override {
        std::cout << "绘制矩形，尺寸: " << width << "x" << height << std::endl;
    }
    double area() const override {
        return width * height;
    }
};

// 简单工厂：图形工厂
class ShapeFactory {
public:
    enum ShapeType { CIRCLE, RECTANGLE };
    
    static Shape* createShape(ShapeType type, double arg1, double arg2 = 0) {
        switch(type) {
            case CIRCLE: return new Circle(arg1);
            case RECTANGLE: return new Rectangle(arg1, arg2);
            default: return nullptr;
        }
    }
};

2.2 实战应用与注意事项

在实际项目中使用简单工厂模式时，有几个关键点需要注意：

1. 参数设计：工厂方法的参数设计要合理，能够支持所有产品的创建需求。在上面的例子中，我们使用第一个参数区分类型，后续参数传递构造所需数据。

2. 错误处理：对于无效类型或非法参数，应该提供明确的处理方式。通常可以选择返回nullptr或抛出异常。

3. 资源管理：在C++中要特别注意内存管理，可以使用智能指针来避免内存泄漏：

cpp复制std::unique_ptr<Shape> circle(
    ShapeFactory::createShape(ShapeFactory::CIRCLE, 5.0)
);

重要提示：简单工厂最大的缺点是违反开闭原则（OCP）。当需要新增产品类型时，必须修改工厂类的创建逻辑。因此它最适合产品类型稳定、变化较少的场景。

3. 工厂方法模式进阶应用

3.1 模式演化与实现细节

工厂方法模式（Factory Method）是对简单工厂的进一步抽象，它将产品创建的逻辑分散到各个具体工厂中。这种模式的核心结构包括：

1. 抽象工厂：定义创建产品的接口
2. 具体工厂：实现抽象工厂接口，创建具体产品
3. 抽象产品：定义产品的公共接口
4. 具体产品：实现抽象产品接口

继续以图形编辑器为例，我们来看工厂方法模式的实现：

cpp复制// 抽象产品
class Shape {
public:
    virtual ~Shape() = default;
    virtual void draw() const = 0;
};

// 具体产品：圆形
class Circle : public Shape {
public:
    void draw() const override {
        std::cout << "绘制圆形" << std::endl;
    }
};

// 具体产品：矩形
class Rectangle : public Shape {
public:
    void draw() const override {
        std::cout << "绘制矩形" << std::endl;
    }
};

// 抽象工厂
class ShapeFactory {
public:
    virtual ~ShapeFactory() = default;
    virtual std::unique_ptr<Shape> createShape() const = 0;
};

// 具体工厂：圆形工厂
class CircleFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape() const override {
        return std::make_unique<Circle>();
    }
};

// 具体工厂：矩形工厂
class RectangleFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape() const override {
        return std::make_unique<Rectangle>();
    }
};

3.2 实际应用场景分析

工厂方法模式特别适合以下场景：

1. 框架设计：当框架需要为多种类型提供扩展点时，可以定义抽象工厂接口，让用户实现自己的具体工厂。

2. 插件系统：每个插件可以提供自己的工厂来创建特定类型的对象。

3. 测试替身：在单元测试中，可以用测试专用的工厂来创建Mock对象。

我在开发一个跨平台UI框架时，就使用了工厂方法模式来处理不同平台下的控件创建。每个平台（Windows、Mac、Linux）都有自己的控件工厂实现，框架代码只需要与抽象工厂和抽象产品交互，完全不需要关心具体实现。

cpp复制// 客户端代码示例
void renderUI(const ShapeFactory& factory) {
    auto shape = factory.createShape();
    shape->draw();
}

int main() {
    CircleFactory circleFactory;
    RectangleFactory rectFactory;
    
    renderUI(circleFactory);  // 绘制圆形
    renderUI(rectFactory);    // 绘制矩形
    
    return 0;
}

4. 抽象工厂模式复杂应用

4.1 产品族概念与实现

抽象工厂模式（Abstract Factory）是三种工厂模式中最复杂的，它用于创建相关或依赖对象的家族，而不需要明确指定具体类。这种模式的核心是"产品族"的概念 - 一组相互关联或依赖的产品。

让我们通过一个跨平台UI的例子来理解这个概念：

cpp复制// 抽象产品：按钮
class Button {
public:
    virtual ~Button() = default;
    virtual void render() const = 0;
};

// 具体产品：Windows按钮
class WindowsButton : public Button {
public:
    void render() const override {
        std::cout << "渲染Windows风格按钮" << std::endl;
    }
};

// 具体产品：Mac按钮
class MacButton : public Button {
public:
    void render() const override {
        std::cout << "渲染Mac风格按钮" << std::endl;
    }
};

// 抽象产品：复选框
class Checkbox {
public:
    virtual ~Checkbox() = default;
    virtual void render() const = 0;
};

// 具体产品：Windows复选框
class WindowsCheckbox : public Checkbox {
public:
    void render() const override {
        std::cout << "渲染Windows风格复选框" << std::endl;
    }
};

// 具体产品：Mac复选框
class MacCheckbox : public Checkbox {
public:
    void render() const override {
        std::cout << "渲染Mac风格复选框" << std::endl;
    }
};

// 抽象工厂
class GUIFactory {
public:
    virtual ~GUIFactory() = default;
    virtual std::unique_ptr<Button> createButton() const = 0;
    virtual std::unique_ptr<Checkbox> createCheckbox() const = 0;
};

// 具体工厂：Windows工厂
class WindowsFactory : public GUIFactory {
public:
    std::unique_ptr<Button> createButton() const override {
        return std::make_unique<WindowsButton>();
    }
    std::unique_ptr<Checkbox> createCheckbox() const override {
        return std::make_unique<WindowsCheckbox>();
    }
};

// 具体工厂：Mac工厂
class MacFactory : public GUIFactory {
public:
    std::unique_ptr<Button> createButton() const override {
        return std::make_unique<MacButton>();
    }
    std::unique_ptr<Checkbox> createCheckbox() const override {
        return std::make_unique<MacCheckbox>();
    }
};

4.2 复杂场景下的最佳实践

在实际开发中，抽象工厂模式特别适合以下场景：

1. 跨平台应用开发：确保同一平台下的UI元素保持风格一致
2. 主题系统：切换不同主题时，所有相关组件一起更换
3. 数据库抽象：为不同数据库提供统一的接口，同时保持特定数据库的特性

我在开发一个支持多数据库的ORM框架时，就使用了抽象工厂模式。每个数据库类型（MySQL、PostgreSQL、SQLite）都有自己的工厂实现，确保连接、查询、事务等组件都是配套的。

cpp复制// 客户端代码示例
class Application {
    std::unique_ptr<GUIFactory> factory;
    
public:
    explicit Application(std::unique_ptr<GUIFactory> f) : factory(std::move(f)) {}
    
    void createUI() {
        auto button = factory->createButton();
        auto checkbox = factory->createCheckbox();
        
        button->render();
        checkbox->render();
    }
};

// 根据当前平台创建合适的工厂
#ifdef _WIN32
    auto factory = std::make_unique<WindowsFactory>();
#else
    auto factory = std::make_unique<MacFactory>();
#endif

Application app(std::move(factory));
app.createUI();

经验分享：抽象工厂的一个常见挑战是当需要新增产品类型时（比如新增一个TextInput组件），需要修改所有具体工厂类。在实践中，可以通过为产品接口提供默认实现或使用注册机制来缓解这个问题。

5. 三种工厂模式的对比与选型指南

5.1 核心差异对照分析

为了更清晰地理解三种工厂模式的区别，我整理了这个对比表格：

5.2 实际项目选型建议

根据我在多个项目中的实践经验，以下是工厂模式的选型指南：

1. 选择简单工厂当：

   • 产品类型有限且不太可能增加
   • 想要最简化的实现
   • 可以接受在添加新产品时修改工厂类

2. 选择工厂方法当：

   • 需要灵活地添加新产品类型
   • 产品创建逻辑比较复杂或需要特殊初始化
   • 希望客户端代码只依赖抽象接口

3. 选择抽象工厂当：

   • 需要创建一组相关的对象
   • 需要确保产品之间的兼容性
   • 系统需要支持多个产品家族

在实际项目中，我经常遇到需要组合使用这些模式的情况。例如，在一个电商平台中，可能会使用抽象工厂来创建不同支付网关（PayPal、Stripe）的相关组件，而每个网关内部又使用工厂方法来创建具体的交易处理器。

6. 高级技巧与性能优化

6.1 工厂模式与对象池结合

在高性能场景下，频繁创建销毁对象会影响性能。我们可以将工厂模式与对象池技术结合：

cpp复制template <typename T>
class ObjectPool {
    std::queue<std::unique_ptr<T>> pool;
    
public:
    std::unique_ptr<T> acquire() {
        if (pool.empty()) {
            return std::make_unique<T>();
        }
        auto obj = std::move(pool.front());
        pool.pop();
        return obj;
    }
    
    void release(std::unique_ptr<T> obj) {
        pool.push(std::move(obj));
    }
};

// 带对象池的工厂
class PooledShapeFactory {
    ObjectPool<Circle> circlePool;
    ObjectPool<Rectangle> rectanglePool;
    
public:
    std::unique_ptr<Shape> createCircle() {
        return circlePool.acquire();
    }
    
    std::unique_ptr<Shape> createRectangle() {
        return rectanglePool.acquire();
    }
    
    void recycle(std::unique_ptr<Shape> shape) {
        if (dynamic_cast<Circle*>(shape.get())) {
            circlePool.release(std::unique_ptr<Circle>(
                static_cast<Circle*>(shape.release())));
        }
        // 类似处理其他类型...
    }
};

6.2 使用模板减少重复代码

当实现多个相似工厂时，可以使用模板来减少重复代码：

cpp复制template <typename Product>
class GenericFactory {
public:
    std::unique_ptr<Product> create() const {
        return std::make_unique<Product>();
    }
};

// 使用示例
using CircleFactory = GenericFactory<Circle>;
using RectangleFactory = GenericFactory<Rectangle>;

6.3 工厂模式在现代C++中的改进

C++11引入的新特性可以让工厂模式实现得更优雅：

1. 使用std::function和lambda实现灵活工厂：

cpp复制class ShapeFactory {
    std::unordered_map<
        std::string, 
        std::function<std::unique_ptr<Shape>()>
    > creators;
    
public:
    void registerCreator(const std::string& type, auto&& func) {
        creators[type] = std::forward<decltype(func)>(func);
    }
    
    std::unique_ptr<Shape> create(const std::string& type) const {
        if (auto it = creators.find(type); it != creators.end()) {
            return it->second();
        }
        return nullptr;
    }
};

// 注册创建器
ShapeFactory factory;
factory.registerCreator("circle", [] { return std::make_unique<Circle>(); });

2. 使用变参模板支持带参数的创建：

cpp复制template <typename Product, typename... Args>
class ParametricFactory {
public:
    std::unique_ptr<Product> create(Args... args) const {
        return std::make_unique<Product>(std::forward<Args>(args)...);
    }
};

// 使用示例
using CircleFactory = ParametricFactory<Circle, double>;
auto factory = CircleFactory();
auto circle = factory.create(5.0);  // 创建半径为5的圆

7. 常见问题与解决方案

7.1 循环依赖问题

当工厂和产品之间存在循环依赖时，可以使用前置声明和分离定义来解决：

cpp复制// 前置声明
class Product;

class Factory {
public:
    virtual ~Factory() = default;
    virtual std::unique_ptr<Product> create() const = 0;
};

class Product {
public:
    virtual ~Product() = default;
    // 产品接口
};

// 具体定义放在单独的源文件中

7.2 动态扩展产品类型

如果需要运行时动态添加产品类型，可以使用注册机制：

cpp复制class ShapeFactory {
    using Creator = std::function<std::unique_ptr<Shape>()>;
    std::unordered_map<std::string, Creator> registry;
    
public:
    void registerType(const std::string& name, Creator creator) {
        registry[name] = std::move(creator);
    }
    
    std::unique_ptr<Shape> create(const std::string& name) const {
        if (auto it = registry.find(name); it != registry.end()) {
            return it->second();
        }
        throw std::runtime_error("Unknown shape type");
    }
};

// 使用示例
ShapeFactory factory;
factory.registerType("circle", [] { return std::make_unique<Circle>(); });
auto circle = factory.create("circle");

7.3 多线程环境下的线程安全

在多线程环境中使用工厂模式时，需要注意线程安全问题：

cpp复制class ThreadSafeFactory {
    std::mutex mutex;
    std::unordered_map<std::string, std::shared_ptr<Shape>> prototypes;
    
public:
    void registerPrototype(const std::string& name, std::shared_ptr<Shape> proto) {
        std::lock_guard lock(mutex);
        prototypes[name] = std::move(proto);
    }
    
    std::unique_ptr<Shape> create(const std::string& name) const {
        std::lock_guard lock(mutex);
        if (auto it = prototypes.find(name); it != prototypes.end()) {
            return it->second->clone();
        }
        return nullptr;
    }
};

8. 设计模式组合应用实例

8.1 工厂模式与单例模式结合

在某些场景下，我们可能希望工厂实例是唯一的：

cpp复制class SingletonFactory {
    SingletonFactory() = default;
    
public:
    static SingletonFactory& instance() {
        static SingletonFactory inst;
        return inst;
    }
    
    std::unique_ptr<Shape> createCircle() const {
        return std::make_unique<Circle>();
    }
    
    // 禁用拷贝
    SingletonFactory(const SingletonFactory&) = delete;
    SingletonFactory& operator=(const SingletonFactory&) = delete;
};

// 使用示例
auto& factory = SingletonFactory::instance();
auto circle = factory.createCircle();

8.2 工厂模式与建造者模式结合

对于复杂对象的创建，可以结合建造者模式：

cpp复制class ComplexShapeBuilder {
    std::vector<std::unique_ptr<Shape>> parts;
    
public:
    ComplexShapeBuilder& addCircle(double radius) {
        parts.push_back(std::make_unique<Circle>(radius));
        return *this;
    }
    
    ComplexShapeBuilder& addRectangle(double w, double h) {
        parts.push_back(std::make_unique<Rectangle>(w, h));
        return *this;
    }
    
    std::unique_ptr<Shape> build() {
        // 返回组合形状或第一个形状等
        return std::move(parts.front());
    }
};

// 使用示例
auto shape = ComplexShapeBuilder()
    .addCircle(5.0)
    .addRectangle(4.0, 6.0)
    .build();

8.3 工厂模式与策略模式结合

根据不同的策略选择不同的工厂：

cpp复制class ShapeCreationStrategy {
public:
    virtual ~ShapeCreationStrategy() = default;
    virtual std::unique_ptr<Shape> create() const = 0;
};

class DefaultShapeStrategy : public ShapeCreationStrategy {
public:
    std::unique_ptr<Shape> create() const override {
        return std::make_unique<Circle>();
    }
};

class SpecialShapeStrategy : public ShapeCreationStrategy {
public:
    std::unique_ptr<Shape> create() const override {
        return std::make_unique<Rectangle>();
    }
};

class Context {
    std::unique_ptr<ShapeCreationStrategy> strategy;
    
public:
    explicit Context(std::unique_ptr<ShapeCreationStrategy> s) 
        : strategy(std::move(s)) {}
        
    std::unique_ptr<Shape> createShape() const {
        return strategy->create();
    }
};

9. 测试与调试技巧

9.1 单元测试工厂模式

测试工厂类时，应该验证：

1. 工厂能否正确创建预期类型的对象
2. 创建的对象是否具有正确的初始状态
3. 错误处理是否合理

cpp复制TEST(ShapeFactoryTest, CreatesCorrectType) {
    CircleFactory factory;
    auto shape = factory.createShape();
    EXPECT_NE(dynamic_cast<Circle*>(shape.get()), nullptr);
}

TEST(ShapeFactoryTest, HandlesInvalidInput) {
    ShapeFactory factory;
    EXPECT_EQ(factory.createShape("invalid"), nullptr);
}

9.2 使用Mock对象测试工厂依赖

在测试依赖工厂的代码时，可以使用Mock工厂：

cpp复制class MockShapeFactory : public ShapeFactory {
public:
    MOCK_METHOD(std::unique_ptr<Shape>, createShape, (), (const override));
};

TEST(ClientTest, UsesFactoryCorrectly) {
    MockShapeFactory mockFactory;
    EXPECT_CALL(mockFactory, createShape())
        .WillOnce(Return(std::make_unique<Circle>()));
    
    Client client(mockFactory);
    client.drawShape();
}

9.3 性能分析与优化

使用性能分析工具检查工厂创建对象的开销：

1. 对象创建时间：测量工厂创建对象所需时间
2. 内存分配：分析工厂模式引入的内存分配模式
3. 缓存效应：评估对象创建对CPU缓存的影响

对于性能敏感的场景，可以考虑：

• 使用对象池复用对象
• 预创建常用对象
• 使用placement new减少内存分配开销

10. 现代C++中的替代方案

10.1 使用依赖注入容器

现代C++框架常使用DI容器替代传统工厂：

cpp复制class DIContainer {
    std::unordered_map<std::type_index, std::function<std::any()>> creators;
    
public:
    template <typename T>
    void registerFactory(std::function<std::unique_ptr<T>()> creator) {
        creators[typeid(T)] = [creator] { return creator(); };
    }
    
    template <typename T>
    std::unique_ptr<T> resolve() const {
        if (auto it = creators.find(typeid(T)); it != creators.end()) {
            return std::any_cast<std::unique_ptr<T>>(it->second());
        }
        return nullptr;
    }
};

// 使用示例
DIContainer container;
container.registerFactory<Shape>([] { return std::make_unique<Circle>(); });
auto shape = container.resolve<Shape>();

10.2 使用Concept约束工厂接口

C++20的Concept可以更好地约束工厂接口：

cpp复制template <typename T>
concept ShapeFactory = requires(T factory) {
    { factory.create() } -> std::convertible_to<std::unique_ptr<Shape>>;
};

template <ShapeFactory Factory>
void renderShape(const Factory& factory) {
    auto shape = factory.create();
    shape->draw();
}

10.3 使用元编程实现编译期工厂

对于类型已知的场景，可以使用模板元编程实现编译期工厂：

cpp复制template <typename... Products>
class PolyFactory {
public:
    template <typename T>
    std::unique_ptr<T> create() const {
        static_assert((std::is_same_v<T, Products> || ...), 
            "Unsupported product type");
        return std::make_unique<T>();
    }
};

// 使用示例
using MyFactory = PolyFactory<Circle, Rectangle>;
MyFactory factory;
auto circle = factory.create<Circle>();

11. 实际项目经验分享

11.1 日志系统中的工厂应用

在我参与的一个高性能日志系统中，我们使用抽象工厂模式来支持不同的日志输出方式（文件、控制台、网络等）。每个日志输出方式都是一个产品族，包含日志写入器、格式化器等相关组件。

cpp复制class LogWriter {
public:
    virtual ~LogWriter() = default;
    virtual void write(const std::string& msg) = 0;
};

class LogFormatter {
public:
    virtual ~LogFormatter() = default;
    virtual std::string format(const LogEntry& entry) = 0;
};

class LogFactory {
public:
    virtual ~LogFactory() = default;
    virtual std::unique_ptr<LogWriter> createWriter() = 0;
    virtual std::unique_ptr<LogFormatter> createFormatter() = 0;
};

// 具体实现略...

这种设计使得我们可以轻松添加新的日志输出方式，同时确保每个输出方式的所有组件都能协同工作。

11.2 游戏开发中的对象创建

在游戏开发中，工厂模式常用于创建游戏实体。我曾经使用工厂方法模式来实现一个灵活的敌人生成系统：

cpp复制class Enemy {
public:
    virtual ~Enemy() = default;
    virtual void update() = 0;
    virtual void render() = 0;
};

class EnemyFactory {
public:
    virtual ~EnemyFactory() = default;
    virtual std::unique_ptr<Enemy> createEnemy() = 0;
    virtual std::unique_ptr<Enemy> createBoss() = 0;
};

// 区域特定的敌人工厂
class ForestEnemyFactory : public EnemyFactory {
public:
    std::unique_ptr<Enemy> createEnemy() override {
        return std::make_unique<ForestMonster>();
    }
    std::unique_ptr<Enemy> createBoss() override {
        return std::make_unique<ForestBoss>();
    }
};

这种设计使得我们可以根据游戏区域创建风格一致的敌人，同时保持代码的灵活性和可扩展性。

11.3 遇到的坑与解决方案

1. 工厂接口膨胀问题：随着系统演进，抽象工厂接口可能会变得过于庞大。解决方案是遵循接口隔离原则，将大工厂拆分为多个小工厂。

2. 对象生命周期管理：工厂创建的对象可能需要在特定条件下销毁。解决方案是使用智能指针并明确所有权关系。

3. 测试复杂性：工厂模式有时会增加测试的复杂性。解决方案是结合Mock对象和依赖注入，提高代码的可测试性。

12. 性能考量与优化实践

12.1 对象创建开销分析

工厂模式的主要性能开销来自：

1. 虚函数调用（动态绑定）
2. 动态内存分配
3. 可能的类型检查（dynamic_cast等）

通过性能分析，我们发现典型的工厂方法调用开销大约在10-30纳秒（现代CPU），对于大多数应用可以忽略不计。但在高性能场景下，这些开销可能需要优化。

12.2 优化技巧实测

1. 使用自定义内存分配器：预先分配对象池，减少动态内存分配开销。

cpp复制template <typename T>
class ObjectPool {
    std::vector<std::unique_ptr<T>> pool;
public:
    template <typename... Args>
    std::unique_ptr<T> create(Args&&... args) {
        if (pool.empty()) {
            return std::make_unique<T>(std::forward<Args>(args)...);
        }
        auto obj = std::move(pool.back());
        pool.pop_back();
        return obj;
    }
    
    void recycle(std::unique_ptr<T> obj) {
        pool.push_back(std::move(obj));
    }
};

2. 减少虚函数调用：在某些情况下，可以使用模板和CRTP模式减少虚函数调用。

cpp复制template <typename Derived>
class ShapeFactoryBase {
public:
    auto create() const {
        return static_cast<const Derived*>(this)->createImpl();
    }
};

class CircleFactory : public ShapeFactoryBase<CircleFactory> {
public:
    std::unique_ptr<Circle> createImpl() const {
        return std::make_unique<Circle>();
    }
};

3. 批量创建：对于需要创建大量对象的场景，提供批量创建接口。

cpp复制class BatchShapeFactory {
public:
    virtual std::vector<std::unique_ptr<Shape>> createBatch(size_t count) const {
        std::vector<std::unique_ptr<Shape>> result;
        result.reserve(count);
        for (size_t i = 0; i < count; ++i) {
            result.push_back(create());
        }
        return result;
    }
};

12.3 真实案例性能数据

在一个图形处理应用中，我们对比了不同工厂实现的性能：

数据表明，在极端性能敏感的场景下，选择合适的工厂实现可以带来显著的性能提升。

13. 扩展阅读与资源推荐

13.1 经典书籍章节

1. 《设计模式：可复用面向对象软件的基础》（GoF书） - 工厂方法、抽象工厂模式章节
2. 《Effective C++》 - 条款4：确定对象被使用前已先被初始化
3. 《Modern C++ Design》 - 泛型工厂模式实现

13.2 开源项目参考

1. Qt框架：QWidget和QML中的工厂模式应用
2. LLVM编译器：AST节点创建中的工厂模式
3. Boost库：Boost.DI依赖注入库

13.3 进阶学习路径

1. 深入理解依赖注入与控制反转（IoC）
2. 学习C++模板元编程实现编译期工厂
3. 研究不同语言（Java、C#）中工厂模式的实现差异
4. 探索领域特定语言（DSL）与工厂模式的结合

14. 个人实践心得

在我多年的C++开发经历中，工厂模式是使用频率最高的设计模式之一。以下是一些个人总结的经验：

1. 不要过度设计：不是所有对象创建都需要工厂。只有当创建逻辑复杂或需要解耦时，才考虑引入工厂模式。

2. 优先选择简单实现：能从简单工厂满足需求时，就不要引入更复杂的工厂方法或抽象工厂。

3. 注意生命周期管理：C++中没有垃圾回收，工厂返回的指针所有权必须清晰。现代C++中优先使用智能指针。

4. 保持工厂单一职责：一个工厂应该只负责创建一种类型的对象或对象族。避免创建"全能"工厂。

5. 测试友好设计：设计工厂接口时要考虑如何方便测试，比如支持注入Mock对象。

工厂模式就像软件开发中的瑞士军刀，看似简单但应用广泛。掌握好各种工厂模式的适用场景和实现技巧，能够让你的代码更加灵活、可维护。