【C++实战㊵】C++抽象工厂模式：解锁高效对象创建的密钥

奔跑吧邓邓子2025-09-26 20:53

目录

  • 一、抽象工厂模式的概念
    • [1.1 抽象工厂模式的定义](#1.1 抽象工厂模式的定义)
    • [1.2 抽象工厂模式的适用场景](#1.2 抽象工厂模式的适用场景)
    • [1.3 抽象工厂模式的结构](#1.3 抽象工厂模式的结构)
  • 二、抽象工厂模式的实战应用
    • [2.1 抽象工厂模式的实现代码](#2.1 抽象工厂模式的实现代码)
    • [2.2 抽象工厂模式与工厂方法模式的对比](#2.2 抽象工厂模式与工厂方法模式的对比)
    • [2.3 抽象工厂模式的产品族扩展方法](#2.3 抽象工厂模式的产品族扩展方法)
  • 三、抽象工厂模式的实战技巧
    • [3.1 抽象工厂模式的退化场景](#3.1 抽象工厂模式的退化场景)
    • [3.2 抽象工厂模式与依赖注入的结合](#3.2 抽象工厂模式与依赖注入的结合)
    • [3.3 抽象工厂模式的线程安全处理](#3.3 抽象工厂模式的线程安全处理)
  • [四、实战项目：跨平台 UI 组件库（抽象工厂版）](#四、实战项目：跨平台 UI 组件库（抽象工厂版）)
    • [4.1 项目需求](#4.1 项目需求)
    • [4.2 抽象工厂模式实现跨平台组件创建](#4.2 抽象工厂模式实现跨平台组件创建)
    • [4.3 不同平台下的 UI 组件渲染测试](#4.3 不同平台下的 UI 组件渲染测试)

一、抽象工厂模式的概念

1.1 抽象工厂模式的定义

抽象工厂模式是一种创建型设计模式，它提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。在抽象工厂模式中，客户端通过抽象工厂接口来创建对象，具体的创建过程由具体工厂类实现。这种模式将对象的创建和使用分离，使得代码的可维护性和可扩展性大大提高。例如，在一个游戏开发项目中，可能需要创建不同类型的角色、武器和装备等对象，这些对象之间存在一定的关联和依赖关系。使用抽象工厂模式，可以将这些对象的创建逻辑封装在抽象工厂接口和具体工厂类中，客户端只需要通过抽象工厂接口来获取所需的对象，而无需关心对象的具体创建过程。这样，当游戏需求发生变化，需要添加新的角色、武器或装备时，只需要在具体工厂类中实现相应的创建逻辑，而不会影响到客户端的代码。

1.2 抽象工厂模式的适用场景

  • 产品族创建：当系统需要创建一系列相关或相互依赖的对象，且这些对象属于同一个产品族时，抽象工厂模式非常适用。比如，在一个家具生产系统中，可能有现代风格和古典风格的家具产品族，每个产品族都包含沙发、茶几、电视柜等产品。使用抽象工厂模式，可以为每个产品族创建一个具体工厂，负责创建该产品族中的所有产品，从而保证产品族中对象的一致性和兼容性。
  • 跨平台开发：在跨平台开发中，不同的操作系统或平台可能需要不同的实现方式来创建对象。例如，在开发一个跨平台的图形用户界面（GUI）应用程序时，Windows、Mac 和 Linux 系统下的按钮、文本框等 UI 组件的创建和绘制方式可能不同。抽象工厂模式可以为每个平台创建一个具体工厂，负责创建该平台下的 UI 组件，使得应用程序能够轻松地在不同平台上运行，同时保持代码的简洁和可维护性。

1.3 抽象工厂模式的结构

  • 抽象工厂：定义了创建一系列相关或相互依赖对象的接口，是具体工厂的抽象父类。它声明了创建不同类型产品的方法，但不涉及具体产品的创建逻辑。例如，在一个图形绘制系统中，抽象工厂可能定义了创建形状（如圆形、矩形）和颜色（如红色、蓝色）的方法。
  • 具体工厂：实现了抽象工厂接口，负责创建具体的产品对象。每个具体工厂对应一个特定的产品族，创建该产品族中的所有产品。比如，在上述图形绘制系统中，可能有一个具体工厂负责创建 Windows 风格的形状和颜色对象，另一个具体工厂负责创建 Mac 风格的形状和颜色对象。
  • 抽象产品族：定义了一组相关产品的公共接口，是具体产品的抽象父类。它描述了产品的基本功能和行为，但不涉及具体的实现细节。例如，在一个电商系统中，抽象产品族可能包括商品、订单和支付方式等接口，定义了这些产品的基本操作和属性。
  • 具体产品：实现了抽象产品族接口，是具体工厂创建的目标对象。每个具体产品对应一个特定的实现，具有具体的功能和行为。比如，在上述电商系统中，可能有具体的商品类（如电子产品、服装）、订单类（如普通订单、加急订单）和支付方式类（如支付宝、微信支付），它们分别实现了相应的抽象产品族接口。

二、抽象工厂模式的实战应用

2.1 抽象工厂模式的实现代码

下面以产品族 A 和产品族 B 为例，给出 C++ 实现抽象工厂模式的具体代码。假设产品族 A 包含产品 A1 和产品 B1，产品族 B 包含产品 A2 和产品 B2。

首先，定义抽象产品类：

cpp 复制代码 
// 抽象产品A
class AbstractProductA {
public:
    virtual ~AbstractProductA() {}
    virtual void OperationA() = 0;
};

// 抽象产品B
class AbstractProductB {
public:
    virtual ~AbstractProductB() {}
    virtual void OperationB() = 0;
};

然后，定义具体产品类：

cpp 复制代码 
// 具体产品A1，属于产品族A
class ProductA1 : public AbstractProductA {
public:
    void OperationA() override {
        std::cout << "ProductA1's OperationA" << std::endl;
    }
};

// 具体产品B1，属于产品族A
class ProductB1 : public AbstractProductB {
public:
    void OperationB() override {
        std::cout << "ProductB1's OperationB" << std::endl;
    }
};

// 具体产品A2，属于产品族B
class ProductA2 : public AbstractProductA {
public:
    void OperationA() override {
        std::cout << "ProductA2's OperationA" << std::endl;
    }
};

// 具体产品B2，属于产品族B
class ProductB2 : public AbstractProductB {
public:
    void OperationB() override {
        std::cout << "ProductB2's OperationB" << std::endl;
    }
};

接着，定义抽象工厂类：

cpp 复制代码 
// 抽象工厂
class AbstractFactory {
public:
    virtual ~AbstractFactory() {}
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};

最后，定义具体工厂类：

cpp 复制代码 
// 具体工厂1，创建产品族A
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() override {
        return new ProductA1();
    }

    AbstractProductB* CreateProductB() override {
        return new ProductB1();
    }
};

// 具体工厂2，创建产品族B
class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() override {
        return new ProductA2();
    }

    AbstractProductB* CreateProductB() override {
        return new ProductB2();
    }
};

在上述代码中，通过抽象工厂类AbstractFactory定义了创建产品 A 和产品 B 的接口，具体工厂类ConcreteFactory1和ConcreteFactory2分别实现了创建产品族 A 和产品族 B 的具体逻辑。客户端可以通过抽象工厂接口来创建所需的产品对象，而无需关心具体的产品实现类。

2.2 抽象工厂模式与工厂方法模式的对比

  • 工厂方法模式：工厂方法模式定义了一个用于创建对象的接口，但由子类决定要实例化的具体类。它只有一个抽象产品类和一个抽象工厂类，每个具体工厂类只能创建一个具体产品类的实例。例如，在一个汽车生产系统中，可能有一个抽象的汽车工厂类，以及具体的宝马汽车工厂类和奥迪汽车工厂类，每个具体工厂类只能创建对应的宝马汽车或奥迪汽车。
  • 抽象工厂模式：抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它有多个抽象产品类和一个抽象工厂类，每个具体工厂类可以创建多个具体产品类的实例，这些产品构成一个产品族。比如，在一个家电生产系统中，可能有一个抽象的家电工厂类，以及具体的海尔家电工厂类和美的家电工厂类，每个具体工厂类可以创建海尔或美的品牌下的电视机、电冰箱、洗衣机等多种家电产品。

在实际应用中，选择工厂方法模式还是抽象工厂模式，需要根据具体的业务需求来决定。如果系统只需要创建一种类型的产品，或者产品之间没有明显的关联和依赖关系，那么工厂方法模式就足够了；如果系统需要创建一系列相关或相互依赖的产品，且这些产品属于同一个产品族，那么抽象工厂模式更为合适。

2.3 抽象工厂模式的产品族扩展方法

当需要在已有抽象工厂模式基础上添加新的产品族时，为了保持代码的可维护性和扩展性，可以按照以下步骤进行：

  1. 定义新的抽象产品：在抽象产品族接口中添加新的抽象产品接口，定义其公共方法。例如，在一个图形绘制系统中，已有抽象产品族包括形状和颜色，现在要添加一个新的产品族 ------ 字体，那么就需要定义一个抽象的字体类，声明字体的相关操作方法，如设置字体大小、字体样式等。
  2. 实现新的具体产品：为新的抽象产品创建具体的实现类，实现抽象产品接口中定义的方法。比如，针对上述抽象字体类，创建具体的宋体字体类、黑体字体类等，分别实现设置字体大小、字体样式等方法。
  3. 扩展抽象工厂接口：在抽象工厂接口中添加创建新抽象产品的方法声明。例如，在图形绘制系统的抽象工厂接口中，添加创建字体的方法声明。
  4. 实现新的具体工厂：创建新的具体工厂类，实现抽象工厂接口中新增的创建新抽象产品的方法，同时实现已有抽象产品的创建方法，确保新的具体工厂能够创建新的产品族中的所有产品。比如，创建一个专门用于绘制 Windows 风格图形的具体工厂类，在这个类中实现创建 Windows 风格的形状、颜色和字体的方法。通过以上步骤，可以在不修改现有代码的基础上，方便地添加新的产品族，符合开闭原则，使系统具有良好的可维护性和扩展性。

三、抽象工厂模式的实战技巧

3.1 抽象工厂模式的退化场景

在单一产品族的情况下，抽象工厂模式会出现退化的情况。此时，抽象工厂模式的结构和功能会变得相对简单，与工厂方法模式较为相似。因为只存在一个产品族，所以抽象工厂中创建不同产品的方法实际上只对应一种具体产品的创建。例如，在一个只生产手机的工厂中，只有一个手机产品族，抽象工厂中创建手机的方法就只有一种具体实现，即创建该品牌和型号的手机。在这种退化场景下，抽象工厂模式的优势可能无法充分体现，因为它的设计初衷是为了管理多个相关产品族的创建。然而，从代码结构和可维护性的角度来看，即使是单一产品族，使用抽象工厂模式仍然可以将对象的创建逻辑封装起来，使代码更加清晰和易于维护。例如，当手机的生产流程或配置发生变化时，只需要在具体工厂类中修改创建手机的逻辑，而不会影响到其他使用该手机对象的代码。

3.2 抽象工厂模式与依赖注入的结合

依赖注入是一种设计模式，它通过将对象的依赖关系从类内部转移到外部配置或注入，从而提高代码的可维护性、可测试性和可扩展性。将抽象工厂模式与依赖注入相结合，可以进一步提升代码的质量。在这种结合方式中，抽象工厂负责创建对象，而依赖注入则负责将创建好的对象注入到需要使用它们的类中。例如，在一个电商系统中，订单服务类需要依赖商品对象和支付方式对象。可以使用抽象工厂创建商品和支付方式的具体实例，然后通过依赖注入将这些实例传递给订单服务类。这样，订单服务类就不需要自己创建依赖对象，降低了类之间的耦合度。同时，在测试订单服务类时，可以通过依赖注入轻松地替换为模拟对象，便于进行单元测试和集成测试，提高了代码的可测试性。此外，通过依赖注入，可以方便地根据不同的业务需求或环境配置，注入不同的具体工厂，实现产品族的灵活切换，增强了代码的可维护性和可扩展性。

3.3 抽象工厂模式的线程安全处理

在多线程环境下，确保抽象工厂模式的线程安全至关重要。因为抽象工厂可能会被多个线程同时访问，如果不进行适当的处理，可能会导致数据不一致或其他线程安全问题。一种常见的线程安全处理方法是使用锁机制。例如，可以在抽象工厂类的创建方法中使用互斥锁，确保同一时间只有一个线程能够调用创建方法，从而避免多个线程同时创建对象导致的冲突。以下是使用 C++ 中的互斥锁实现线程安全的抽象工厂的示例代码：

cpp 复制代码 
#include <iostream>
#include <memory>
#include <mutex>

// 抽象产品A
class AbstractProductA {
public:
    virtual ~AbstractProductA() {}
    virtual void OperationA() = 0;
};

// 抽象产品B
class AbstractProductB {
public:
    virtual ~AbstractProductB() {}
    virtual void OperationB() = 0;
};

// 具体产品A1，属于产品族A
class ProductA1 : public AbstractProductA {
public:
    void OperationA() override {
        std::cout << "ProductA1's OperationA" << std::endl;
    }
};

// 具体产品B1，属于产品族A
class ProductB1 : public AbstractProductB {
public:
    void OperationB() override {
        std::cout << "ProductB1's OperationB" << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual ~AbstractFactory() {}
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};

// 具体工厂1，创建产品族A
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() override {
        std::lock_guard<std::mutex> lock(mutex_);
        return new ProductA1();
    }

    AbstractProductB* CreateProductB() override {
        std::lock_guard<std::mutex> lock(mutex_);
        return new ProductB1();
    }

private:
    std::mutex mutex_;
};

在上述代码中，ConcreteFactory1类中使用了std::lock_guardstd::mutex来自动管理互斥锁的生命周期，当进入创建方法时自动加锁，离开方法时自动解锁，从而保证了线程安全。除了锁机制，还可以使用线程本地存储（TLS）等技术来确保抽象工厂模式在多线程环境下的正确性和稳定性。线程本地存储为每个线程提供独立的存储空间，避免了多线程对共享资源的竞争，从而提高了系统的并发性能。

四、实战项目：跨平台 UI 组件库（抽象工厂版）

4.1 项目需求

在开发一个跨平台的应用程序时，需要一套能够在 Windows 和 Linux 平台上都能正常工作的 UI 组件库，包括按钮、文本框和窗口组件。具体需求如下：

  • 按钮组件：在 Windows 平台上，按钮应具有 Windows 风格的外观和交互效果，例如按钮的颜色、边框样式和点击反馈等符合 Windows 操作系统的设计规范；在 Linux 平台上，按钮应呈现出 Linux 系统特有的风格，如 GNOME 桌面环境下的按钮样式，同时要保证按钮的基本功能（如点击事件的响应）在两个平台上都能正常实现。
  • 文本框组件：Windows 平台下的文本框要支持 Windows 系统默认的文本输入和编辑功能，如快捷键操作（Ctrl+C、Ctrl+V 等），并且外观上与 Windows 系统的文本框一致；Linux 平台上的文本框需适应不同的桌面环境（如 GNOME、KDE 等），具备相应的风格特点，同时也要确保文本输入和编辑的稳定性和兼容性。
  • 窗口组件：对于 Windows 平台，窗口应具备 Windows 操作系统的窗口特性，如标题栏的样式、窗口的最大化、最小化和关闭按钮的位置与功能等；在 Linux 平台上，窗口要符合 Linux 系统的窗口管理规范，并且能够在不同的 Linux 发行版上正常显示和操作，保证窗口的布局和交互逻辑在两个平台上的一致性。

4.2 抽象工厂模式实现跨平台组件创建

首先，定义抽象产品类，包括抽象按钮类、抽象文本框类和抽象窗口类：

cpp 复制代码 
// 抽象按钮类
class AbstractButton {
public:
    virtual ~AbstractButton() {}
    virtual void Render() = 0;
};

// 抽象文本框类
class AbstractTextBox {
public:
    virtual ~AbstractTextBox() {}
    virtual void Display() = 0;
};

// 抽象窗口类
class AbstractWindow {
public:
    virtual ~AbstractWindow() {}
    virtual void Show() = 0;
};

然后，定义具体产品类，分别实现 Windows 和 Linux 平台下的按钮、文本框和窗口组件：

cpp 复制代码 
// Windows平台下的按钮类
class WindowsButton : public AbstractButton {
public:
    void Render() override {
        std::cout << "Rendering Windows Button" << std::endl;
    }
};

// Windows平台下的文本框类
class WindowsTextBox : public AbstractTextBox {
public:
    void Display() override {
        std::cout << "Displaying Windows TextBox" << std::endl;
    }
};

// Windows平台下的窗口类
class WindowsWindow : public AbstractWindow {
public:
    void Show() override {
        std::cout << "Showing Windows Window" << std::endl;
    }
};

// Linux平台下的按钮类
class LinuxButton : public AbstractButton {
public:
    void Render() override {
        std::cout << "Rendering Linux Button" << std::endl;
    }
};

// Linux平台下的文本框类
class LinuxTextBox : public AbstractTextBox {
public:
    void Display() override {
        std::cout << "Displaying Linux TextBox" << std::endl;
    }
};

// Linux平台下的窗口类
class LinuxWindow : public AbstractWindow {
public:
    void Show() override {
        std::cout << "Showing Linux Window" << std::endl;
    }
};

接着，定义抽象工厂类，声明创建不同平台 UI 组件的方法：

cpp 复制代码 
// 抽象工厂类
class AbstractGUIFactory {
public:
    virtual ~AbstractGUIFactory() {}
    virtual AbstractButton* CreateButton() = 0;
    virtual AbstractTextBox* CreateTextBox() = 0;
    virtual AbstractWindow* CreateWindow() = 0;
};

最后，定义具体工厂类，实现创建 Windows 和 Linux 平台下 UI 组件的逻辑：

cpp 复制代码 
// Windows平台的具体工厂类
class WindowsGUIFactory : public AbstractGUIFactory {
public:
    AbstractButton* CreateButton() override {
        return new WindowsButton();
    }

    AbstractTextBox* CreateTextBox() override {
        return new WindowsTextBox();
    }

    AbstractWindow* CreateWindow() override {
        return new WindowsWindow();
    }
};

// Linux平台的具体工厂类
class LinuxGUIFactory : public AbstractGUIFactory {
public:
    AbstractButton* CreateButton() override {
        return new LinuxButton();
    }

    AbstractTextBox* CreateTextBox() override {
        return new LinuxTextBox();
    }

    AbstractWindow* CreateWindow() override {
        return new LinuxWindow();
    }
};

在上述代码中，通过抽象工厂模式，将不同平台下 UI 组件的创建逻辑封装在具体工厂类中。客户端可以根据运行的平台选择相应的具体工厂来创建所需的 UI 组件，从而实现跨平台的 UI 组件创建。

4.3 不同平台下的 UI 组件渲染测试

为了验证跨平台 UI 组件库在不同平台下的正确性和稳定性，进行如下测试：

  1. 测试方案 ：
    • 编写测试用例，分别在 Windows 和 Linux 平台上创建按钮、文本框和窗口组件，并调用它们的渲染或显示方法，观察输出结果是否符合预期。
    • 测试组件的交互功能，如按钮的点击事件处理、文本框的文本输入和编辑功能等，确保这些功能在两个平台上都能正常工作。
    • 在不同的 Linux 发行版（如 Ubuntu、CentOS 等）上进行测试，验证 UI 组件库的兼容性。
  2. 测试结果 ：
    • 在 Windows 平台上，创建的 WindowsButton、WindowsTextBox 和 WindowsWindow 组件能够正确渲染和显示，按钮的点击事件响应正常，文本框的文本输入和编辑功能也符合预期。
    • 在 Linux 平台上，无论是 Ubuntu 还是 CentOS，LinuxButton、LinuxTextBox 和 LinuxWindow 组件都能成功渲染和显示，并且交互功能稳定可靠。
    • 通过对不同平台下 UI 组件的全面测试，验证了跨平台 UI 组件库在不同平台上的正确性和稳定性，能够满足项目的需求。
相关推荐
jf加菲猫2 小时前
条款11：优先选用删除函数，而非private未定义函数
开发语言·c++
怀旧,4 小时前
【C++】23. C++11（上）
开发语言·c++
小卡皮巴拉4 小时前
【笔试强训】Day1
开发语言·数据结构·c++·算法
初圣魔门首席弟子4 小时前
switch缺少break出现bug
c++·算法·bug
进步青年ccc5 小时前
C++ IO 库全方位解析：从基础到实战
c++·io
博界IT精灵6 小时前
C++入门
c++
泽虞6 小时前
《C++程序设计》笔记p4
linux·开发语言·c++·笔记·算法
什么半岛铁盒6 小时前
C++项目：仿muduo库高并发服务器--------Any类的实现
linux·服务器·数据库·c++·mysql·github
玖笙&6 小时前
✨WPF编程基础【1.1】：XAML文档框架
c++·visualstudio·wpf
热门推荐
01Multisim使用教程详尽版--(2025最新版)02UV 工具安装与国内镜像源配置指南03GitHub 镜像站点0446个Nano-banana 精选提示词，持续更新中05Spec-Kit 使用指南06UV安装并设置国内源07保姆级教程：手把手教你用Dify实现完美多轮对话（附Chatflow和提示词）08VsCode远程Copilot无法使用Claude Agent问题092025年华为杯研赛数学建模竞赛C题完整参考论文 （含模型、MATLAB和Python代码）10KGG转MP3工具|非KGM文件|解密音频