C++工厂模式：从基础到高级变体实践

1. 工厂模式在C++中的核心价值

工厂模式作为创建型设计模式的代表，在C++领域有着独特的应用场景。与Java等语言不同，C++没有内置的反射机制，这使得工厂模式在对象创建过程中扮演着更为关键的角色。想象一下你在开发一个图形编辑器，需要根据用户输入创建不同形状（圆形、矩形、三角形等），工厂模式就能优雅地解决这类"运行时动态创建对象"的需求。

传统工厂模式通常包含三个核心组件：

1. 抽象产品接口（如Shape）
2. 具体产品实现（如Circle, Rectangle）
3. 工厂类（负责根据输入参数创建具体产品）

但在实际C++开发中，我们会遇到各种需要调整基础工厂模式的情况。比如：

• 需要创建的对象类型在编译期无法确定
• 产品构造过程异常复杂，包含多步初始化
• 需要控制实例的数量或生命周期
• 产品族之间存在关联关系

这些问题催生了工厂模式的多种变体，每种变体都针对特定场景提供了更优的解决方案。下面我们就深入探讨几种最实用的变体实现。

2. 简单工厂模式：入门首选

简单工厂（Simple Factory）是最基础的实现形式，虽然不属于GoF 23种设计模式之一，但在小型项目中非常实用。它的核心思想是将对象创建逻辑集中管理。

2.1 经典实现示例

cpp复制class Shape {
public:
    virtual void draw() = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape {
public:
    void draw() override { cout << "Drawing Circle" << endl; }
};

class Rectangle : public Shape {
public:
    void draw() override { cout << "Drawing Rectangle" << endl; }
};

class ShapeFactory {
public:
    static Shape* createShape(const string& type) {
        if (type == "Circle") return new Circle();
        if (type == "Rectangle") return new Rectangle();
        return nullptr;
    }
};

2.2 优缺点分析

优点：

• 客户端与具体类解耦
• 创建逻辑集中管理，便于修改

缺点：

• 违反开闭原则（新增类型需修改工厂类）
• 工厂类职责过重，随着类型增多会变得臃肿

提示：简单工厂适合类型较少且不频繁变化的场景。当类型超过5-6种时，建议考虑更高级的变体。

3. 工厂方法模式：多态创建的典范

工厂方法模式（Factory Method）通过引入抽象工厂接口，解决了简单工厂的开闭原则问题。每个具体产品对应一个具体工厂，新增类型时只需扩展新的工厂类。

3.1 UML结构解析

code复制[Creator] <|-- [ConcreteCreator1]
[Creator] <|-- [ConcreteCreator2]
[Product] <|-- [ConcreteProduct1]
[Product] <|-- [ConcreteProduct2]

3.2 C++实现示例

cpp复制class ShapeFactory {
public:
    virtual Shape* create() = 0;
    virtual ~ShapeFactory() = default;
};

class CircleFactory : public ShapeFactory {
public:
    Shape* create() override { return new Circle(); }
};

class RectangleFactory : public ShapeFactory {
public:
    Shape* create() override { return new Rectangle(); }
};

// 使用示例
ShapeFactory* factory = new CircleFactory();
Shape* shape = factory->create();
shape->draw();

3.3 应用场景

• 框架需要为不同平台创建UI组件
• 类库需要提供扩展点让用户定义自己的产品
• 测试中需要mock对象的创建

我在实际项目中发现，工厂方法模式特别适合插件式架构。每个插件可以提供自己的工厂实现，主程序通过抽象接口调用，完全不需要知道具体类型。

4. 抽象工厂模式：产品族的解决方案

当需要创建相关或依赖的对象家族时，抽象工厂（Abstract Factory）就派上用场了。它扩展了工厂方法的概念，一个工厂接口可以创建多个相关产品。

4.1 经典案例：GUI组件库

假设我们要开发跨平台的GUI库，不同平台（Windows/Mac）有各自的按钮和复选框实现：

cpp复制class Button {
public:
    virtual void render() = 0;
};

class WinButton : public Button {
    void render() override { /* Windows风格渲染 */ }
};

class MacButton : public Button {
    void render() override { /* Mac风格渲染 */ }
};

class GUIFactory {
public:
    virtual Button* createButton() = 0;
    virtual Checkbox* createCheckbox() = 0;
};

class WinFactory : public GUIFactory {
    Button* createButton() override { return new WinButton(); }
    Checkbox* createCheckbox() override { return new WinCheckbox(); }
};

class MacFactory : public GUIFactory {
    Button* createButton() override { return new MacButton(); }
    Checkbox* createCheckbox() override { return new MacCheckbox(); }
};

4.2 关键优势

• 确保创建的产品相互兼容
• 客户端代码与具体产品解耦
• 产品族切换非常方便（只需更换工厂实例）

注意：抽象工厂的扩展性较差。新增产品类型（如RadioButton）需要修改所有工厂类，这被称为"横切关注点"问题。

5. 注册式工厂：运行时灵活性

注册式工厂（Registered Factory）通过将类型注册机制引入工厂，提供了更大的灵活性。这是我在大型项目中经常采用的变体。

5.1 实现原理

1. 使用map保存类型名称与创建函数的映射
2. 提供注册接口供具体产品注册自己
3. 工厂根据名称查找并调用对应的创建函数

cpp复制class ShapeFactory {
private:
    using Creator = function<Shape*()>;
    static unordered_map<string, Creator> creators;
    
public:
    static void registerShape(const string& type, Creator creator) {
        creators[type] = creator;
    }
    
    static Shape* create(const string& type) {
        auto it = creators.find(type);
        if (it != creators.end()) 
            return it->second();
        return nullptr;
    }
};

// 注册示例
ShapeFactory::registerShape("Circle", []{ return new Circle(); });

5.2 优势与陷阱

优势：

• 完全遵循开闭原则
• 支持动态注册新类型
• 可用于插件系统

陷阱：

• 注册时机需要谨慎控制
• 类型安全问题（字符串作为键）
• 多线程环境需要加锁

我在实际使用中发现，结合静态变量自动注册可以简化使用：

cpp复制struct AutoRegister {
    AutoRegister(const string& name, ShapeFactory::Creator creator) {
        ShapeFactory::registerShape(name, creator);
    }
};

#define REGISTER_SHAPE(type) \
    static AutoRegister _autoReg_##type(#type, []{ return new type(); })

6. 单例工厂与对象池：资源控制

某些场景下我们需要控制实例的数量或生命周期，这时可以结合单例模式或对象池模式。

6.1 单例工厂实现

cpp复制class DatabaseConnectionFactory {
private:
    static DatabaseConnection* instance;
    
public:
    static DatabaseConnection* getConnection() {
        if (!instance) {
            instance = new DatabaseConnection();
            // 复杂初始化逻辑...
        }
        return instance;
    }
    
    static void releaseConnection() {
        delete instance;
        instance = nullptr;
    }
};

6.2 对象池扩展

cpp复制class ConnectionPool {
private:
    queue<DatabaseConnection*> pool;
    mutex mtx;
    
public:
    ConnectionPool(size_t size) {
        for (size_t i = 0; i < size; ++i) {
            pool.push(new DatabaseConnection());
        }
    }
    
    DatabaseConnection* acquire() {
        lock_guard<mutex> lock(mtx);
        if (pool.empty()) return nullptr;
        auto conn = pool.front();
        pool.pop();
        return conn;
    }
    
    void release(DatabaseConnection* conn) {
        lock_guard<mutex> lock(mtx);
        pool.push(conn);
    }
};

这种模式特别适合数据库连接、线程等重量级资源的创建管理。我在高并发系统中实测，使用对象池可以将连接创建开销降低70%以上。

7. 模板工厂：编译期多态

C++的模板元编程能力让我们可以在编译期实现工厂模式，完全消除运行时开销。

7.1 基本模板工厂

cpp复制template <typename T>
class TemplateFactory {
public:
    static T* create() {
        return new T();
    }
};

// 使用示例
auto shape = TemplateFactory<Circle>::create();

7.2 带参数的进阶版本

cpp复制template <typename Base, typename... Args>
class AdvancedTemplateFactory {
public:
    template <typename T>
    static Base* create(Args... args) {
        return new T(std::forward<Args>(args)...);
    }
};

// 使用示例
auto circle = AdvancedTemplateFactory<Shape, int>::create<Circle>(10);  // 半径10的圆

模板工厂的优势：

• 零运行时开销
• 类型安全（编译期检查）
• 支持任意构造函数参数

缺点：

• 错误信息晦涩难懂
• 灵活性较低（类型必须在编译期确定）

我在数值计算库中经常使用这种模式，特别是当性能是关键考量时。

8. 实践中的经验与陷阱

经过多年C++项目实践，我总结了以下工厂模式的使用心得：

8.1 生命周期管理

工厂模式常与智能指针结合使用，避免内存泄漏：

cpp复制unique_ptr<Shape> shape(ShapeFactory::create("Circle"));

8.2 异常安全

工厂方法应该处理构造失败的情况：

cpp复制try {
    auto resource = ResourceFactory::create();
} catch (const CreationException& e) {
    // 处理创建失败
}

8.3 性能考量

对于频繁创建的小对象，可以考虑：

• 对象池模式
• 预分配内存
• 使用placement new减少分配开销

8.4 测试友好性

工厂模式极大简化了单元测试：

cpp复制class MockShape : public Shape {
    void draw() override { /* 测试实现 */ }
};

TEST_F(ShapeTest, DrawTest) {
    ShapeFactory::registerShape("Mock", []{ return new MockShape(); });
    auto shape = ShapeFactory::create("Mock");
    // 验证draw行为...
}

8.5 常见陷阱

1. 循环依赖：工厂知道产品，产品又依赖工厂
2. 过度设计：简单场景不需要复杂工厂
3. 类型爆炸：太多具体工厂类增加维护成本
4. 忘记销毁：特别是使用原始指针时

我在一个图像处理项目中曾遇到过一个典型问题：由于工厂创建的对象在不同模块间传递，导致难以追踪所有权，最终改用shared_ptr解决了生命周期管理问题。