设计模式(C++)详解—工厂方法模式(1)

青草地溪水旁2025-09-12 16:42

<摘要>

工厂方法模式是一种创建型设计模式，它通过定义创建对象的接口，但将具体实例化工作延迟到子类中来实现对象的创建。本文从工厂方法模式的历史背景和发展脉络出发，系统阐述了其在软件框架设计和对象创建解耦中的核心作用。通过深入分析模式的设计意图、抽象工厂与具体工厂的关系、开闭原则的实现机制，详细剖析了工厂方法模式在依赖倒置、扩展性和封装性方面的设计考量。文章结合跨平台GUI组件创建、文档处理系统、支付网关集成和日志系统等实际应用场景，提供了完整的可编译代码示例和Makefile配置，并使用UML类图和时序图直观展示了模式的结构和交互流程。最后，总结了工厂方法模式的适用场景、最佳实践以及与其他创建型模式的对比，为开发者提供了全面而实用的指导。

<解析>

1. 背景与核心概念

1.1 产生背景与发展脉络

工厂方法模式（Factory Method Pattern）的诞生源于面向对象软件开发中对对象创建过程的抽象需求。在早期的软件开发中，对象创建通常直接使用new操作符，这导致了代码的高度耦合和难以维护。

历史演进阶段：

  1. 简单工厂阶段（1980年代）：最初开发者使用简单的工厂类来封装对象创建逻辑，但这违反了开闭原则，因为添加新产品需要修改工厂类。

  2. 模式化阶段（1990年代）：在"Gang of Four"的《设计模式：可复用面向对象软件的基础》中，工厂方法模式被正式提出，作为对简单工厂的改进，通过引入继承和多态机制实现了真正的扩展性。

  3. 框架化阶段（2000年代至今）：随着各种应用框架（如GUI框架、游戏引擎、企业级框架）的兴起，工厂方法模式成为框架设计的核心模式，用于实现框架与具体实现的解耦。

产生的根本原因：

  • 解耦需求：将对象创建与使用分离，降低代码耦合度
  • 扩展性需求：支持新产品类型的添加而不修改现有代码
  • 框架设计需求：为框架提供可扩展的钩子方法
  • 配置灵活性：支持运行时动态决定创建的对象类型

1.2 核心概念与关键术语

工厂方法模式（Factory Method Pattern）：定义一个用于创建对象的接口，但让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

关键参与者：

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

核心特性：

  • 创建封装性：将对象创建过程封装在工厂方法中
  • 多态性：利用多态机制实现不同产品的创建
  • 延迟绑定：具体产品的创建延迟到子类中实现
  • 框架集成：为框架提供可扩展的创建点

UML表示：
Creator +factoryMethod() : Product +someOperation() : void ConcreteCreatorA +factoryMethod() : Product ConcreteCreatorB +factoryMethod() : Product <<interface>> Product +operation() : void ConcreteProductA +operation() : void ConcreteProductB +operation() : void

图1.1：工厂方法模式UML类图

2. 设计意图与考量

2.1 核心设计目标

工厂方法模式的设计旨在解决以下核心问题：

2.1.1 解耦对象创建与使用

将对象创建过程从客户端代码中分离出来，客户端只需要知道产品的接口，而不需要关心具体的实现类。这降低了客户端与具体产品类之间的耦合度。

2.1.2 支持开闭原则

通过工厂方法模式，系统可以在不修改现有代码的情况下引入新的产品类型。只需要添加新的具体创建者和具体产品类即可扩展系统功能。

2.1.3 提供框架扩展点

在框架设计中，工厂方法为框架用户提供了明确的扩展点。框架定义创建接口，而用户提供具体实现，实现了框架与具体实现的分离。

2.1.4 统一创建接口

为相关或依赖对象的创建提供统一的接口，使得客户端代码可以以统一的方式处理不同的产品变体。

2.2 设计考量因素

2.2.1 抽象级别设计

工厂方法模式的关键在于正确设计抽象层次：

  • 产品接口应该足够抽象，能够涵盖所有具体产品的共同行为
  • 工厂方法应该返回抽象产品类型，而不是具体类型
  • 具体创建者应该与具体产品一一对应或有明确的映射关系

2.2.2 命名约定

工厂方法的命名通常遵循一定的约定：

  • createXXX()
  • makeXXX()
  • newInstance()
  • getXXX()

2.2.3 参数化工厂方法

工厂方法可以接受参数来决定创建哪种具体产品：

cpp 复制代码 
class Creator {
public:
    virtual Product* createProduct(ProductType type) {
        switch(type) {
            case TYPE_A: return new ConcreteProductA();
            case TYPE_B: return new ConcreteProductB();
            default: return nullptr;
        }
    }
};

但这种实现方式又回到了简单工厂的模式，违反了开闭原则。更好的方式是通过多态来实现。

2.2.4 模板方法模式结合

工厂方法经常与模板方法模式结合使用：

cpp 复制代码 
class Creator {
public:
    // 模板方法
    void operation() {
        Product* product = createProduct();
        product->doSomething();
        // 其他操作
    }
    
    // 工厂方法
    virtual Product* createProduct() = 0;
};

3. 实例与应用场景

3.1 跨平台GUI组件创建

应用场景 ：

在跨平台GUI框架中，需要为不同操作系统创建相应的UI组件，如按钮、文本框等。工厂方法模式可以让我们为每个平台提供特定的创建者。

完整实现代码：

cpp 复制代码 
// gui_components.h
#ifndef GUI_COMPONENTS_H
#define GUI_COMPONENTS_H

#include <iostream>
#include <string>

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

// 具体产品：Windows按钮
class WindowsButton : public Button {
public:
    void render() const override {
        std::cout << "渲染一个Windows风格的按钮" << std::endl;
    }
    
    void onClick() const override {
        std::cout << "Windows按钮被点击了!" << std::endl;
    }
};

// 具体产品：MacOS按钮
class MacOSButton : public Button {
public:
    void render() const override {
        std::cout << "渲染一个MacOS风格的按钮" << std::endl;
    }
    
    void onClick() const override {
        std::cout << "MacOS按钮被点击了!" << std::endl;
    }
};

// 抽象产品：文本框接口
class TextBox {
public:
    virtual ~TextBox() = default;
    virtual void render() const = 0;
    virtual void onInput(const std::string& text) const = 0;
};

// 具体产品：Windows文本框
class WindowsTextBox : public TextBox {
public:
    void render() const override {
        std::cout << "渲染一个Windows风格的文本框" << std::endl;
    }
    
    void onInput(const std::string& text) const override {
        std::cout << "Windows文本框收到输入: " << text << std::endl;
    }
};

// 具体产品：MacOS文本框
class MacOSTextBox : public TextBox {
public:
    void render() const override {
        std::cout << "渲染一个MacOS风格的文本框" << std::endl;
    }
    
    void onInput(const std::string& text) const override {
        std::cout << "MacOS文本框收到输入: " << text << std::endl;
    }
};

// 抽象创建者：GUI工厂
class GUIFactory {
public:
    virtual ~GUIFactory() = default;
    virtual Button* createButton() const = 0;
    virtual TextBox* createTextBox() const = 0;
};

// 具体创建者：Windows GUI工厂
class WindowsFactory : public GUIFactory {
public:
    Button* createButton() const override {
        return new WindowsButton();
    }
    
    TextBox* createTextBox() const override {
        return new WindowsTextBox();
    }
};

// 具体创建者：MacOS GUI工厂
class MacOSFactory : public GUIFactory {
public:
    Button* createButton() const override {
        return new MacOSButton();
    }
    
    TextBox* createTextBox() const override {
        return new MacOSTextBox();
    }
};

#endif // GUI_COMPONENTS_H
cpp 复制代码 
// main_gui.cpp
#include "gui_components.h"
#include <memory>

// 客户端代码
class Application {
private:
    std::unique_ptr<GUIFactory> factory_;
    
public:
    Application(std::unique_ptr<GUIFactory> factory) 
        : factory_(std::move(factory)) {}
    
    void createUI() {
        // 使用工厂方法创建UI组件
        std::unique_ptr<Button> button(factory_->createButton());
        std::unique_ptr<TextBox> textbox(factory_->createTextBox());
        
        // 使用创建的组件
        button->render();
        textbox->render();
        
        button->onClick();
        textbox->onInput("Hello, Factory Method!");
    }
};

int main() {
    // 根据当前平台选择适当的工厂
    std::string platform;
    std::cout << "请输入平台 (windows/macos): ";
    std::cin >> platform;
    
    std::unique_ptr<GUIFactory> factory;
    
    if (platform == "windows") {
        factory = std::make_unique<WindowsFactory>();
        std::cout << "创建Windows UI组件..." << std::endl;
    } else if (platform == "macos") {
        factory = std::make_unique<MacOSFactory>();
        std::cout << "创建MacOS UI组件..." << std::endl;
    } else {
        std::cout << "不支持的平台，使用默认工厂" << std::endl;
        // 可以根据需要选择默认工厂
        factory = std::make_unique<WindowsFactory>();
    }
    
    // 创建应用并使用工厂
    Application app(std::move(factory));
    app.createUI();
    
    return 0;
}

Makefile配置：

makefile 复制代码 
# Makefile for GUI Factory example
CXX = g++
CXXFLAGS = -std=c++14 -Wall -Wextra

TARGET = gui_factory_example
SOURCES = main_gui.cpp
HEADERS = gui_components.h

$(TARGET): $(SOURCES) $(HEADERS)
	$(CXX) $(CXXFLAGS) -o $(TARGET) $(SOURCES)

clean:
	rm -f $(TARGET)

run: $(TARGET)
	./$(TARGET)

.PHONY: clean run

编译运行：

bash 复制代码 
make        # 编译程序
make run    # 运行程序

3.2 文档处理系统

应用场景 ：

文档处理系统需要支持多种文档格式（如PDF、Word、Excel），每种格式有不同的解析和保存方式。工厂方法模式可以为每种文档格式提供特定的创建逻辑。

完整实现代码：

cpp 复制代码 
// document_system.h
#ifndef DOCUMENT_SYSTEM_H
#define DOCUMENT_SYSTEM_H

#include <iostream>
#include <string>
#include <memory>

// 抽象产品：文档接口
class Document {
public:
    virtual ~Document() = default;
    virtual void open() = 0;
    virtual void save() = 0;
    virtual void close() = 0;
    virtual std::string getType() const = 0;
};

// 具体产品：PDF文档
class PDFDocument : public Document {
public:
    void open() override {
        std::cout << "打开PDF文档，进行PDF特定解析..." << std::endl;
    }
    
    void save() override {
        std::cout << "保存PDF文档，使用PDF格式保存..." << std::endl;
    }
    
    void close() override {
        std::cout << "关闭PDF文档，释放PDF相关资源..." << std::endl;
    }
    
    std::string getType() const override {
        return "PDF";
    }
};

// 具体产品：Word文档
class WordDocument : public Document {
public:
    void open() override {
        std::cout << "打开Word文档，进行DOCX格式解析..." << std::endl;
    }
    
    void save() override {
        std::cout << "保存Word文档，使用DOCX格式保存..." << std::endl;
    }
    
    void close() override {
        std::cout << "关闭Word文档，释放Word相关资源..." << std::endl;
    }
    
    std::string getType() const override {
        return "Word";
    }
};

// 具体产品：Excel文档
class ExcelDocument : public Document {
public:
    void open() override {
        std::cout << "打开Excel文档，进行XLSX格式解析..." << std::endl;
    }
    
    void save() override {
        std::cout << "保存Excel文档，使用XLSX格式保存..." << std::endl;
    }
    
    void close() override {
        std::cout << "关闭Excel文档，释放Excel相关资源..." << std::endl;
    }
    
    std::string getType() const override {
        return "Excel";
    }
};

// 抽象创建者：文档工厂
class DocumentFactory {
public:
    virtual ~DocumentFactory() = default;
    virtual std::unique_ptr<Document> createDocument() = 0;
    virtual std::string getFactoryType() const = 0;
};

// 具体创建者：PDF文档工厂
class PDFDocumentFactory : public DocumentFactory {
public:
    std::unique_ptr<Document> createDocument() override {
        return std::make_unique<PDFDocument>();
    }
    
    std::string getFactoryType() const override {
        return "PDF";
    }
};

// 具体创建者：Word文档工厂
class WordDocumentFactory : public DocumentFactory {
public:
    std::unique_ptr<Document> createDocument() override {
        return std::make_unique<WordDocument>();
    }
    
    std::string getFactoryType() const override {
        return "Word";
    }
};

// 具体创建者：Excel文档工厂
class ExcelDocumentFactory : public DocumentFactory {
public:
    std::unique_ptr<Document> createDocument() override {
        return std::make_unique<ExcelDocument>();
    }
    
    std::string getFactoryType() const override {
        return "Excel";
    }
};

#endif // DOCUMENT_SYSTEM_H
cpp 复制代码 
// main_document.cpp
#include "document_system.h"
#include <map>
#include <functional>

// 文档处理器
class DocumentProcessor {
private:
    std::map<std::string, std::function<std::unique_ptr<DocumentFactory>()>> factories_;
    
public:
    DocumentProcessor() {
        // 注册所有可用的文档工厂
        registerFactory("pdf", []() { return std::make_unique<PDFDocumentFactory>(); });
        registerFactory("word", []() { return std::make_unique<WordDocumentFactory>(); });
        registerFactory("excel", []() { return std::make_unique<ExcelDocumentFactory>(); });
    }
    
    void registerFactory(const std::string& type, 
                        std::function<std::unique_ptr<DocumentFactory>()> factoryCreator) {
        factories_[type] = factoryCreator;
    }
    
    void processDocument(const std::string& documentType) {
        auto it = factories_.find(documentType);
        if (it == factories_.end()) {
            std::cout << "不支持的文档类型: " << documentType << std::endl;
            return;
        }
        
        // 创建相应的文档工厂
        auto factory = it->second();
        std::cout << "使用 " << factory->getFactoryType() << " 工厂创建文档..." << std::endl;
        
        // 使用工厂方法创建文档
        auto document = factory->createDocument();
        
        // 处理文档
        std::cout << "处理 " << document->getType() << " 文档:" << std::endl;
        document->open();
        document->save();
        document->close();
        
        std::cout << std::endl;
    }
};

int main() {
    DocumentProcessor processor;
    
    // 处理不同类型的文档
    std::cout << "=== 文档处理系统演示 ===" << std::endl;
    
    processor.processDocument("pdf");
    processor.processDocument("word");
    processor.processDocument("excel");
    
    // 尝试处理不支持的文档类型
    processor.processDocument("ppt");
    
    return 0;
}

Makefile配置：

makefile 复制代码 
# Makefile for Document System example
CXX = g++
CXXFLAGS = -std=c++14 -Wall -Wextra

TARGET = document_system_example
SOURCES = main_document.cpp
HEADERS = document_system.h

$(TARGET): $(SOURCES) $(HEADERS)
	$(CXX) $(CXXFLAGS) -o $(TARGET) $(SOURCES)

clean:
	rm -f $(TARGET)

run: $(TARGET)
	./$(TARGET)

.PHONY: clean run

编译运行：

bash 复制代码 
make        # 编译程序
make run    # 运行程序

4. 交互性内容解析

4.1 工厂方法模式的交互流程

工厂方法模式的核心交互发生在客户端、创建者和产品之间。以下时序图展示了典型的交互流程：
Client ConcreteCreator ConcreteProduct 需要产品对象 createProduct() 工厂方法被调用 new ConcreteProduct() 返回产品对象 使用产品接口操作对象 operation() 返回操作结果 Client ConcreteCreator ConcreteProduct

图4.1：工厂方法模式时序图

4.2 带参数工厂方法的交互

在某些情况下，工厂方法可能需要参数来决定创建哪种具体产品：
Client Creator ConcreteProductA ConcreteProductB 需要特定类型的产品 createProduct(type) new ConcreteProductA() 返回ProductA new ConcreteProductB() 返回ProductB alt [type == TYPE_A] [type == TYPE_B] operation() 返回结果 Client Creator ConcreteProductA ConcreteProductB

图4.2：参数化工厂方法时序图

5. 工厂方法模式变体与对比

5.1 工厂方法模式变体

5.1.1 参数化工厂方法

通过参数指定要创建的产品类型，但需要注意保持开闭原则。

5.1.2 模板工厂方法

使用C++模板来实现工厂方法：

cpp 复制代码 
template<typename ProductType>
class Creator {
public:
    virtual ProductType* createProduct() = 0;
};

class ConcreteCreator : public Creator<ConcreteProduct> {
public:
    ConcreteProduct* createProduct() override {
        return new ConcreteProduct();
    }
};

5.1.3 单例工厂

将工厂实现为单例，确保全局只有一个工厂实例：

cpp 复制代码 
class ProductFactory {
private:
    static ProductFactory* instance;
    ProductFactory() = default;
    
public:
    static ProductFactory* getInstance() {
        if (instance == nullptr) {
            instance = new ProductFactory();
        }
        return instance;
    }
    
    virtual Product* createProduct() = 0;
};

5.2 与其他创建型模式对比

模式 目的 适用场景 特点
工厂方法 让子类决定实例化哪个类 类需要延迟实例化到子类时 通过继承实现，需要子类
抽象工厂 创建相关或依赖对象家族 需要创建一系列相关产品时 通过组合实现，产品族
建造者 分步创建复杂对象 对象构造过程复杂，需要分步时 关注构造过程，分步构建
原型 通过克隆创建对象 创建成本高或需要动态配置时 通过复制现有对象创建

6. 总结与最佳实践

6.1 工厂方法模式适用场景

工厂方法模式在以下场景中特别有用：

  1. 框架设计：为框架提供可扩展的创建点
  2. 跨平台开发：为不同平台创建相应的组件
  3. 插件系统：动态加载和创建插件实例
  4. 测试驱动开发：创建模拟对象进行测试
  5. 对象池管理：管理可重用对象的创建和回收

6.2 最佳实践建议

  1. 遵循依赖倒置原则：客户端应该依赖抽象（接口），而不是具体实现
  2. 使用智能指针 ：使用std::unique_ptr或std::shared_ptr管理产品对象的生命周期
  3. 提供默认实现：在抽象创建者中可以提供工厂方法的默认实现
  4. 使用注册机制：支持动态注册新的具体创建者，增强扩展性
  5. 考虑性能影响：对于性能敏感的场景，评估工厂方法带来的开销

6.3 C++特定实现技巧

  1. 使用返回类型协变：C++支持工厂方法的返回类型协变，子类可以返回更具体的类型
cpp 复制代码 
class BaseCreator {
public:
    virtual BaseProduct* create() = 0;
};

class DerivedCreator : public BaseCreator {
public:
    // 返回类型协变：返回派生类指针
    DerivedProduct* create() override {
        return new DerivedProduct();
    }
};

  1. 使用模板减少重复代码：通过模板实现通用的产品注册和创建机制

  2. 结合异常安全：确保工厂方法在异常情况下的资源安全

cpp 复制代码 
std::unique_ptr<Product> createProduct() {
    auto rawPtr = new ConcreteProduct();
    try {
        rawPtr->initialize(); // 可能抛出异常
    } catch (...) {
        delete rawPtr;
        throw;
    }
    return std::unique_ptr<Product>(rawPtr);
}

工厂方法模式是面向对象设计中极其重要的模式，它通过将对象创建过程抽象化，实现了创建者与具体产品的解耦，为系统提供了良好的扩展性和灵活性。正确使用工厂方法模式可以显著提高代码的可维护性和可测试性。

相关推荐
·白小白2 小时前
C++类（上）默认构造和运算符重载
c++·学习
染指11103 小时前
11.ImGui-加载字体和中文
c++·windows·imgui
浩浩乎@4 小时前
【openGLES】纹理
c++·opengles
叫我龙翔4 小时前
【设计模式】从游戏角度开始了解设计模式 --- 抽象工厂模式
c++·游戏·设计模式
青草地溪水旁4 小时前
设计模式(C++)详解—单例模式(1)
c++·单例模式
HMBBLOVEPDX5 小时前
C++（深拷贝和浅拷贝）
开发语言·c++·浅拷贝和深拷贝
UrSpecial6 小时前
Linux线程
linux·开发语言·c++
郝学胜-神的一滴6 小时前
深入浅出 C++20：新特性与实践
开发语言·c++·程序人生·算法·c++20
汉克老师6 小时前
第十四届蓝桥杯青少组C++选拔赛[2023.1.15]第二部分编程题（2 、寻宝石）
c++·蓝桥杯·蓝桥杯c++·c++蓝桥杯·蓝桥杯选拔赛
热门推荐
01conda中设置镜像地址（附所有可换的地址）02UV安装并设置国内源03保姆级教程：手把手教你用Dify实现完美多轮对话（附Chatflow和提示词）04UV 工具安装与国内镜像源配置指南05A股预测还能更准？开源大模型Kronos带你跑通预测+回测全流程06GitHub 镜像站点07突破百度网盘的下载限速，两种方法教会你【超详细】08KGG转MP3工具|非KGM文件|解密音频09教你如何认证 Gemini 教育优惠的二次验证，薅个 1年的 Gemini Pro 会员1046个Nano-banana 精选提示词，持续更新中