C++设计模式——Abstract Factory Pattern抽象工厂模式

🕗 发布于 2024-11-25 15:44 设计模式抽象工厂模式 c++ c语言 开发语言

一、抽象工厂模式的定义

抽象工厂模式是一种创建型设计模式，它提供了一种将相关/依赖对象组合在一起创建的方式，而无需指定它们的具体类。

抽象工厂模式与工厂方法模式的区别：

工厂方法模式将对象的创建过程延迟到子类中，允许用户通过一个统一的接口来请求他们想要的具体产品，而无需知道产品的具体实现。在这个模式中，工厂类只负责生产同一系列的产品，但具体哪种产品由子类决定。

抽象工厂模式更进一步，它提供了一个接口，用于创建一系列相关的或相互依赖的对象，而不是单一对象。抽象工厂封装了产品系列的创建逻辑，客户端不需要知道如何创建具体的产品对象，只需要关心最终能得到哪些产品。这种模式通常用于解决产品集的变化而无需修改客户端代码的情况。

当需要面对多个产品等级结构时，更推荐使用抽象工厂模式。

抽象工厂模式在现实生活中的抽象实例：

汽车制造：对于每个品牌的汽车，公司都有不同的组件供应商，例如发动机、座椅和轮胎供应商。在抽象工厂模式中，汽车制造公司充当工厂角色，而不同品牌的汽车和不同的组件供应商充当具体产品。

美食餐厅：餐厅可以提供多种类型的饮料和食物，比如咖啡和披萨。每种类型的饮料和食物都有不同的原料供应商。在抽象工厂模式中，餐厅充当工厂角色，而不同类型的饮料和食物以及不同的原料供应商充当具体产品。

电子产品制造：假设有一家电子产品制造公司，对于每种电子产品，公司都有不同的组件供应商，例如显示屏、处理器和电池供应商。在抽象工厂模式中，电子产品制造公司充当工厂角色，而不同类型的电子产品和不同的组件供应商充当具体产品。

二、抽象工厂模式的结构

抽象工厂模式主要包含以下组件：

1.抽象工厂(AbstractFactory)：它声明了创建一系列具有相同接口的对象的方法，这些对象代表不同的产品。

2.具体工厂(ConcreteFactory)：是抽象工厂的具体实现，负责创建具体产品对象。每个具体工厂对应了一系列的具体产品。

3.抽象产品(AbstractProduct)：它声明了产品对象的接口，包含了创建产品的公共方法。

4.具体产品(ConcreteProduct)：是抽象产品的具体实现。

组件之间的工作步骤如下：

1.定义一个抽象工厂类，这个类声明了一系列产品的创建方法，但不提供方法的具体代码实现。

2.代码在特定的上下文环境中调用具体工厂对象来负责创建一系列的产品。

3. 当客户端需要一个产品时，它向抽象工厂发送请求。抽象工厂根据当前需求选择合适的具体工厂，并由该工厂返回所需的产品实例。

抽象工厂模式将具体产品的创建和使用进行了解耦，使得客户端与具体产品的实现分离，能够很方便地替换不同的产品系列。

对应UML类图：

三、抽象工厂模式代码样例

#include <iostream>
using namespace std;
// Abstract Product A
class AbstractProductA {
public:
    virtual void operationA() = 0;
};
// Concrete Product A1
class ProductA1 : public AbstractProductA {
public:
    void operationA() override {
        cout << "Product A1 operation" << endl;
    }
};
// Concrete Product A2
class ProductA2 : public AbstractProductA {
public:
    void operationA() override {
        cout << "Product A2 operation" << endl;
    }
};
// Abstract Product B
class AbstractProductB {
public:
    virtual void operationB() = 0;
};
// Concrete Product B1
class ProductB1 : public AbstractProductB {
public:
    void operationB() override {
        cout << "Product B1 operation" << endl;
    }
};
// Concrete Product B2
class ProductB2 : public AbstractProductB {
public:
    void operationB() override {
        cout << "Product B2 operation" << endl;
    }
};
// Abstract Factory
class AbstractFactory {
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};
// Concrete Factory 1
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ProductA1();
    }
    AbstractProductB* createProductB() override {
        return new ProductB1();
    }
};
// Concrete Factory 2
class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ProductA2();
    }
    AbstractProductB* createProductB() override {
        return new ProductB2();
    }
};
int main() {
    AbstractFactory* factory1 = new ConcreteFactory1();
    AbstractProductA* productA1 = factory1->createProductA();
    AbstractProductB* productB1 = factory1->createProductB();
    productA1->operationA();
    productB1->operationB();
    AbstractFactory* factory2 = new ConcreteFactory2();
    AbstractProductA* productA2 = factory2->createProductA();
    AbstractProductB* productB2 = factory2->createProductB();
    productA2->operationA();
    productB2->operationB();
    delete factory1;
    delete factory2;
    delete productA1;
    delete productB1;
    delete productA2;
    delete productB2;
    return 0;
}

运行结果：

Product A1 operation
Product B1 operation
Product A2 operation
Product B2 operation

四、抽象工厂模式的优缺点

抽象工厂模式的优点：

降低了客户端与具体产品的耦合度。

符合单一职责原则，每个具体工厂类只负责创建特定的产品。

隐藏了对象的创建过程，客户端不需要关心具体的对象创建细节，只需要通过工厂接口获取所需对象即可。

抽象工厂模式的缺点：

当产品族中需要增加新的产品时，既需要扩展抽象工厂的接口，又需要新增一个具体工厂类，大大增加了代码的维护成本。

当需要创建的产品种类非常多时，抽象工厂模式的类数量将急剧增加，导致系统难以维护和理解。

五、代码实战

模拟披萨的制作过程：

PizzaFactory：

NewYorkCheesePizza：bake() -> cut() -> box()

NewYorkPepperoniPizza：bake() -> cut() -> box()

ChicagoCheesePizza：bake() -> cut() -> box()

ChicagoPepperoniPizza：bake() -> cut() -> box()

#include <iostream>

class Pizza {
public:
    virtual void bake() = 0;
    virtual void cut() = 0;
    virtual void box() = 0;
};

class NewYorkCheesePizza : public Pizza {
public:
    void bake() override
    {
        std::cout << "Baking New York-style cheese pizza."
                << std::endl;
    }

    void cut() override
    {
        std::cout << "Cutting New York-style cheese pizza."
                << std::endl;
    }

    void box() override
    {
        std::cout << "Boxing New York-style cheese pizza."
                << std::endl;
    }
};

class NewYorkPepperoniPizza : public Pizza {
public:
    void bake() override
    {
        std::cout
            << "Baking New York-style pepperoni pizza."
            << std::endl;
    }

    void cut() override
    {
        std::cout
            << "Cutting New York-style pepperoni pizza."
            << std::endl;
    }

    void box() override
    {
        std::cout
            << "Boxing New York-style pepperoni pizza."
            << std::endl;
    }
};

class ChicagoCheesePizza : public Pizza {
public:
    void bake() override
    {
        std::cout << "Baking Chicago-style cheese pizza."
                << std::endl;
    }

    void cut() override
    {
        std::cout << "Cutting Chicago-style cheese pizza."
                << std::endl;
    }

    void box() override
    {
        std::cout << "Boxing Chicago-style cheese pizza."
                << std::endl;
    }
};

class ChicagoPepperoniPizza : public Pizza {
public:
    void bake() override
    {
        std::cout << "Baking Chicago-style pepperoni pizza."
                << std::endl;
    }

    void cut() override
    {
        std::cout
            << "Cutting Chicago-style pepperoni pizza."
            << std::endl;
    }

    void box() override
    {
        std::cout << "Boxing Chicago-style pepperoni pizza."
                << std::endl;
    }
};

class PizzaFactory {
public:
    virtual Pizza* createCheesePizza() = 0;
    virtual Pizza* createPepperoniPizza() = 0;
};

class NewYorkPizzaFactory : public PizzaFactory {
public:
    Pizza* createCheesePizza() override
    {
        return new NewYorkCheesePizza();
    }

    Pizza* createPepperoniPizza() override
    {
        return new NewYorkPepperoniPizza();
    }
};

class ChicagoPizzaFactory : public PizzaFactory {
public:
    Pizza* createCheesePizza() override
    {
        return new ChicagoCheesePizza();
    }

    Pizza* createPepperoniPizza() override
    {
        return new ChicagoPepperoniPizza();
    }
};

int main()
{
    PizzaFactory* newYorkFactory
        = new NewYorkPizzaFactory();
    Pizza* newYorkCheesePizza
        = newYorkFactory->createCheesePizza();
    Pizza* newYorkPepperoniPizza
        = newYorkFactory->createPepperoniPizza();

    PizzaFactory* chicagoFactory
        = new ChicagoPizzaFactory();
    Pizza* chicagoCheesePizza
        = chicagoFactory->createCheesePizza();
    Pizza* chicagoPepperoniPizza
        = chicagoFactory->createPepperoniPizza();

    newYorkCheesePizza->bake();
    newYorkCheesePizza->cut();
    newYorkCheesePizza->box();

    newYorkPepperoniPizza->bake();
    newYorkPepperoniPizza->cut();
    newYorkPepperoniPizza->box();

    chicagoCheesePizza->bake();
    chicagoCheesePizza->cut();
    chicagoCheesePizza->box();

    chicagoPepperoniPizza->bake();
    chicagoPepperoniPizza->cut();
    chicagoPepperoniPizza->box();

    delete newYorkFactory;
    delete newYorkCheesePizza;
    delete newYorkPepperoniPizza;
    delete chicagoFactory;
    delete chicagoCheesePizza;
    delete chicagoPepperoniPizza;

    return 0;
}

运行结果：

Baking New York-style cheese pizza.
Cutting New York-style cheese pizza.
Boxing New York-style cheese pizza.
Baking New York-style pepperoni pizza.
Cutting New York-style pepperoni pizza.
Boxing New York-style pepperoni pizza.
Baking Chicago-style cheese pizza.
Cutting Chicago-style cheese pizza.
Boxing Chicago-style cheese pizza.
Baking Chicago-style pepperoni pizza.
Cutting Chicago-style pepperoni pizza.
Boxing Chicago-style pepperoni pizza.

六、参考阅读

https://www.fluentcpp.com/2022/04/06/design-patterns-vs-design-principles-abstract-factory/

https://www.geeksforgeeks.org/abstract-factory-pattern-c-design-patterns/

https://sourcemaking.com/design_patterns/abstract_factory/cpp/before-after

https://www.scaler.com/topics/design-patterns/creational-design-pattern/

原文地址：https://blog.csdn.net/CoderZZ_2024/article/details/144013024

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：笔记--以免丢失
下一篇：【SVN和GIT】版本控制系统详细下载使用教程

DataGrip 连接 Redis、TongRDS
有些旧版本没有 redis 驱动用不了。
阅读更多2024-11-25
【PHP】基础语法，自学笔记（二）
基本的加、减、乘、除、取余、以及幂运算。框中的的参数并计算，处理后返回给页面。字符变量，数，布尔，以及。
阅读更多2024-11-25
wordpress中Gravatar用户头像不显示，免插件实现添加自定义设置上传头像功能
虽热这个功能使用场景和频率都非常低，但在有时候还是需要WordPress来显示头像的，但是zuanmang.net并不是每个人都有注册设置Gravatar头像。将下面的代码加入到你主题的Functio
阅读更多2024-11-25
自然语言处理: RAG优化之Embedding模型选型重要依据：mteb/leaderboard榜
近期RAG 应用不断涌现，它们的性能表现各具特色。尽管我们可以通过多个方面（例如查询改写、图像数据处理、分块策略、元数据管理、密集检索、稀疏检索、结果重排、排序融合、提示词优化以及上下文压缩等）逐步优
阅读更多2024-11-25
【Verilog】第三章作业
9. (单选题)下面两段代码中信号in、q1、q2、q3的值分别是0、1、2、3，那么经过1个时钟周期后，左边程序q3的值和右边程序q3的值分别变为（）。写出表达式以实现图1对应电路的逻辑功能
阅读更多2024-11-25
【docker 保存】将Docker镜像保存为一个离线的tar归档文件
将Docker镜像保存为一个离线的tar归档文件，这样就可以在没有网络连接的情况下，或者在不同的机器上使用这个镜像。这个过程通常包括两个步骤：首先是将镜像保存为tar文件，然后是将这个tar文件传输到
阅读更多2024-11-25
Claude Opus MetaPrompt 系统详解
Claude Opus MetaPrompt 系统详解
阅读更多2024-11-25
docker搭建私有仓库，实现镜像的推送和拉取
这么做的目的是【docker默认不允许htp方式推送镜像，通过配置选项来取消这个限制】新增配置【insecure-registries】，将私服仓库的地址加入。192.168.111.162 部署do
阅读更多2024-11-25
手机文件可以打印出来吗
大多数打印店都具备手机文件上传的能力，可以通过无线传输或数据线连接的方式将手机上的文件传输到打印设备上。然而，打印店的价格通常较高，特别是对于大量文件的打印，成本会显著增加。琢贝云打印提供了一种经济实
阅读更多2024-11-25
【基础算法】链表
【代码】【基础算法】链表。
阅读更多2024-11-25