C++工厂方法模式：解耦对象创建的最佳实践

1. 工厂方法模式：解耦对象创建的利器

在C++开发中，我们经常遇到这样的场景：需要创建对象，但又不希望将具体的类名硬编码在客户端代码中。想象一下，你正在开发一个跨平台的GUI库，需要根据不同的操作系统创建对应的按钮控件。如果直接在代码中写死new WindowsButton()或new MacOSButton()，不仅会导致代码难以维护，还会让整个系统丧失灵活性。这正是工厂方法模式大显身手的地方。

工厂方法模式（Factory Method Pattern）是一种经典的创建型设计模式，它定义了一个用于创建对象的接口，但让子类决定实例化哪一个类。简单来说，就是把对象创建的权力下放给子类，让子类来决定具体创建什么对象。这种模式完美遵循了"开闭原则"——对扩展开放，对修改关闭。当需要添加新的产品类型时，你只需要新增对应的工厂子类，而不需要修改现有的客户端代码。

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

1. 类无法预知它需要创建哪些对象
2. 类希望其子类来指定它所创建的对象
3. 需要将对象的创建和使用分离

在实际的C++项目中，工厂方法模式被广泛应用于各种框架和库的设计中。比如在游戏开发中，你可能需要根据不同的关卡创建不同的敌人类型；在数据库访问层，你可能需要根据配置创建不同的数据库连接对象。这些场景下，工厂方法模式都能提供优雅的解决方案。

2. 工厂方法模式的核心结构与实现

2.1 UML类图解析

工厂方法模式的核心结构可以用以下UML类图表示：

code复制[Product] <|-- [ConcreteProduct]
[Creator] <|-- [ConcreteCreator]
[Creator] o--> [Product]

• Product（抽象产品）：定义工厂方法所创建对象的接口
• ConcreteProduct（具体产品）：实现Product接口的具体类
• Creator（抽象工厂）：声明工厂方法，该方法返回一个Product类型的对象
• ConcreteCreator（具体工厂）：重写工厂方法以返回一个ConcreteProduct实例

2.2 C++实现示例

让我们用一个具体的例子来演示如何在C++中实现工厂方法模式。假设我们正在开发一个文档编辑器，需要支持多种文档类型（如TextDocument、SpreadsheetDocument等）。

cpp复制// 抽象产品类
class Document {
public:
    virtual ~Document() = default;
    virtual void open() = 0;
    virtual void save() = 0;
};

// 具体产品类
class TextDocument : public Document {
public:
    void open() override {
        std::cout << "Opening text document..." << std::endl;
    }
    
    void save() override {
        std::cout << "Saving text document..." << std::endl;
    }
};

class SpreadsheetDocument : public Document {
public:
    void open() override {
        std::cout << "Opening spreadsheet document..." << std::endl;
    }
    
    void save() override {
        std::cout << "Saving spreadsheet document..." << std::endl;
    }
};

// 抽象工厂类
class Application {
public:
    virtual ~Application() = default;
    virtual Document* createDocument() = 0;
    
    void newDocument() {
        Document* doc = createDocument();
        docs.push_back(doc);
        doc->open();
    }
    
    void saveAll() {
        for (auto doc : docs) {
            doc->save();
        }
    }

private:
    std::vector<Document*> docs;
};

// 具体工厂类
class TextApplication : public Application {
public:
    Document* createDocument() override {
        return new TextDocument();
    }
};

class SpreadsheetApplication : public Application {
public:
    Document* createDocument() override {
        return new SpreadsheetDocument();
    }
};

在这个实现中，Application是抽象工厂类，它定义了工厂方法createDocument()。TextApplication和SpreadsheetApplication是具体工厂类，它们实现了createDocument()方法来创建具体的文档对象。

2.3 工厂方法的关键特性

1. 延迟实例化：工厂方法让子类决定何时以及如何创建对象，实现了延迟实例化
2. 命名一致性：所有具体工厂都使用相同的工厂方法名，保持了接口一致性
3. 单一职责：将产品创建逻辑集中在一个地方，符合单一职责原则
4. 可扩展性：添加新产品类型只需添加新的工厂子类，无需修改现有代码

注意：在C++实现中，要特别注意内存管理。上面的示例为了简洁省略了内存释放的代码，在实际项目中应该使用智能指针（如std::unique_ptr）来管理动态分配的对象。

3. 工厂方法模式在C++中的高级应用

3.1 参数化工厂方法

有时候，我们需要根据运行时参数来决定创建哪种产品。这时可以使用参数化工厂方法：

cpp复制class Application {
public:
    enum DocType { TEXT, SPREADSHEET };
    
    virtual Document* createDocument(DocType type) {
        switch(type) {
            case TEXT: return new TextDocument();
            case SPREADSHEET: return new SpreadsheetDocument();
            default: throw std::runtime_error("Unknown document type");
        }
    }
};

这种变体简化了类层次结构，但牺牲了一些灵活性——添加新产品类型需要修改工厂类的代码。

3.2 使用模板实现工厂方法

C++的模板机制可以用来实现更灵活的工厂方法：

cpp复制template <typename T>
class Application {
public:
    Document* createDocument() {
        return new T();
    }
};

// 使用方式
Application<TextDocument> textApp;
Document* doc = textApp.createDocument();

模板工厂方法提供了编译时多态性，但失去了运行时动态创建的能力。

3.3 工厂方法与对象注册

对于需要高度动态性的场景，可以结合工厂方法和对象注册机制：

cpp复制class DocumentFactory {
public:
    using Creator = std::function<Document*()>;
    
    void registerCreator(const std::string& type, Creator creator) {
        creators[type] = creator;
    }
    
    Document* createDocument(const std::string& type) {
        auto it = creators.find(type);
        if (it != creators.end()) {
            return it->second();
        }
        throw std::runtime_error("Unknown document type: " + type);
    }

private:
    std::unordered_map<std::string, Creator> creators;
};

// 注册和使用
DocumentFactory factory;
factory.registerCreator("text", []() { return new TextDocument(); });
factory.registerCreator("spreadsheet", []() { return new SpreadsheetDocument(); });

Document* doc = factory.createDocument("text");

这种实现允许在运行时动态注册新的产品类型，非常适合插件式架构。

4. 工厂方法模式的实践技巧与陷阱

4.1 何时使用工厂方法模式

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

1. 框架设计：框架需要标准化架构但允许用户扩展功能
2. 类库设计：类库需要提供灵活的对象创建机制
3. 测试驱动开发：需要隔离被测代码与其依赖的对象创建
4. 跨平台开发：需要为不同平台创建对应的实现

4.2 常见实现陷阱

1. 内存泄漏：忘记释放工厂创建的对象。解决方案是使用智能指针：

cpp复制std::unique_ptr<Document> createDocument() {
    return std::make_unique<TextDocument>();
}

2. 循环依赖：工厂和产品之间出现循环引用。可以通过前向声明和分离接口来解决。

3. 过度设计：对于简单的对象创建需求，直接使用构造函数可能更合适。

4. 性能问题：频繁创建销毁复杂对象可能影响性能。考虑使用对象池模式优化。

4.3 工厂方法与其他模式的比较

1. 与简单工厂比较：

   • 简单工厂将所有创建逻辑集中在一个类中
   • 工厂方法将创建逻辑分散到子类中，更符合开闭原则

2. 与抽象工厂比较：

   • 工厂方法创建单一产品
   • 抽象工厂创建产品族

3. 与原型模式比较：

   • 工厂方法通过子类化来创建对象
   • 原型模式通过克隆现有对象来创建新对象

4.4 现代C++中的改进实现

使用现代C++特性可以写出更安全、更简洁的工厂方法：

cpp复制class DocumentFactory {
public:
    virtual std::unique_ptr<Document> createDocument() = 0;
    virtual ~DocumentFactory() = default;
};

class TextDocumentFactory : public DocumentFactory {
public:
    std::unique_ptr<Document> createDocument() override {
        return std::make_unique<TextDocument>();
    }
};

这种实现使用了std::unique_ptr来自动管理内存，避免了手动内存管理的风险。

在实际项目中，我通常会根据以下因素选择工厂方法的实现方式：

• 如果需要最大灵活性，选择对象注册方式
• 如果产品类型在编译时已知，考虑模板工厂
• 如果内存安全是首要考虑，使用智能指针
• 如果需要跨DLL边界，注意接口设计和内存管理策略