备案控制台
开发者社区 开发与运维 文章 正文

【设计模式学习笔记】简单工厂模式、工厂模式、抽象工厂模式案例详解（C++实现）

2023-02-08 314
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【设计模式学习笔记】简单工厂模式、工厂模式、抽象工厂模式案例详解（C++实现）

一、简单工厂模式

1. 什么是简单工厂模式

Simple Factory Pattern，简单工厂模式，也叫做静态工厂方法模式(Static Factory Method Pattern)。属于类的创建型设计模式的一种，通过一个专门的类（工厂）来负责创建其他类的实例（具体产品），这些类都有一个共同的抽象类作为基类（抽象产品）。

简单工厂模式中的三个角色

  1. 工厂角色：Creator，用于创建所有的具体产品实例，是简单工厂模式的核心。工厂类直接被外部调用，并提供一个静态方法，根据传入的参数不同来创建不同产品类的实例。
  2. 抽象产品角色：Product，它是工厂类所创建的所有实例的类的共同基类，用于描述产品的公共接口。它和工厂类是依赖的关系（作为工厂类静态方法的返回值）。
  3. 具体产品角色：Concrete Product，它是抽象产品类的子类，也是工厂类要创建的目标类。

2. 简单工厂模式实例

假设我们要生产一个手机，由苹果手机，小米手机，首先我们应该定义一个抽象产品类PhoneInterface

1. //抽象产品类
2. class PhoneInterface
3. {
4. public:
5.  virtual void print_brand() = 0;
6. };

然后根据抽象产品类来实现具体的产品类，假设我们有苹果手机和小米手机

1. //具体产品类
2. class apple : public PhoneInterface
3. {
4. public:
5.  virtual void print_brand()
6.  {
7.    cout << "苹果手机" << endl;
8.  }
9. };
10. 
11. 
12. class XiaoMi : public PhoneInterface
13. {
14. public:
15.   virtual void print_brand()
16.   {
17.     cout << "小米手机" << endl;
18.   }
19. };

接下来就应该创建一个工厂类，在工厂类中定义了创建所有产品类实例的逻辑，以及选择创建哪个产品类实例的判断。

1. //工厂类
2. class Factory
3. {
4. public:
5.  PhoneInterface* production_phone(int flag)
6.  {
7.    PhoneInterface* pTemp = NULL;
8.    switch (flag) //所有的生产都集中在一个工厂中，每次修改都要在类中修改，不符合开闭原则
9.    {
10.     case 1:
11.       pTemp = new apple;
12.       break;
13.     case 2:
14.       pTemp = new XiaoMi;
15.       break;
16.     default:
17.       pTemp = NULL;
18.       break;
19.     }
20.     return pTemp;
21.   }
22. };

这样，客户就可以通过工厂类来生产客户所需要的手机，并可以成功完成手机型号的生产。

1. int main()
2. {
3.  Factory* pF = NULL;
4.  PhoneInterface* pPhone = NULL;
5. 
6.  pF = new Factory;
7.  pPhone = pF->production_phone(1);
8.  pPhone->print_brand();
9.  delete pPhone;
10. 
11.   pPhone = pF->production_phone(2);
12.   pPhone->print_brand();
13.   delete pF;
14.   delete pPhone;
15. 
16.   system("pause");
17.   return 0;
18. }

3. 简单工厂模式的优缺点

优点：工厂类是整个简单工厂模式的核心，通过工厂类对外隐藏了创建实例的具体细节，用户直接使用工厂类去创建自己需要的实例，而不必关心实例是如何创建出来的，也不必关心内部结构是怎么组织的。

缺点：正所谓成也萧何，败也萧何，简单工厂模式的优点来源于工厂类，其缺点也来源于工厂类，因为所有实例的创建逻辑都集中在工厂类中，一旦工厂出现问题，所有实例的创建都将无法进行，并且增删产品都要去修改工厂类来实现，不符合开闭原则。因为简单工厂模式不符合开闭原则，所以它不是标准的设计模式。

二、工厂模式

1. 什么是工厂模式

factory pattern，工厂模式同样属于类的创建型模式，也成为多态工厂模式。工厂模式对简单工厂模式不遵守开闭原则这一缺点做了修正，工厂模式多出了一个抽象工厂角色作为接口，实际的生产工作在具体工厂类中实现，这样进一步的抽象化使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。简单来说，就是把简单工厂中的工厂细分为不同产品的工厂，每个工厂生产一种产品。

  1. 抽象工厂角色(Creator)，所有具体工厂都要实现这个接口；
  2. 具体工厂(Concrete Creator)，负责实例化具体产品对象；
  3. 抽象角色(Product)，和简单工厂模式一样，它是工厂类所创建的所有实例的类的共同基类，用于描述产品的公共接口。
  4. 具体产品角色(Concrete Product)，具体工厂类所要实例化的对象。

2. 工厂模式实例

抽象产品类和具体产品类不变 

1. //抽象产品类
2. class PhoneInterface
3. {
4. public:
5.  virtual void print_brand() = 0;
6. };
7. 
8. //苹果手机产品实现
9. class apple : public PhoneInterface
10. {
11. public:
12.   virtual void print_brand()
13.   {
14.     cout << "苹果手机" << endl;
15.   }
16. };
17. 
18. //小米手机产品实现
19. class XiaoMi : public PhoneInterface
20. {
21. public:
22.   virtual void print_brand()
23.   {
24.     cout << "小米手机" << endl;
25.   }
26. };

首先定义一个抽象的工厂类，来定义具体工厂的统一接口

1. //抽象工厂类
2. class FactoryInterface
3. {
4. public:
5.  virtual PhoneInterface* production_phone() = 0;
6. };

然后定义一个苹果手机工厂，用于生产苹果手机，再定义一个小米手机工厂，用于生产苹果手机，那么这两个工厂就是具体工厂角色

1. //苹果手机工厂
2. class AppleFactory : public FactoryInterface
3. {
4. public:
5.  virtual PhoneInterface* production_phone()
6.  {
7.    return new apple;
8.  }
9. };
10. 
11. //小米手机工厂
12. class XiaomiFactory : public FactoryInterface
13. {
14. public:
15.   virtual PhoneInterface* production_phone()
16.   {
17.     return new XiaoMi;
18.   }
19. };

当我们需要生产手机产品的时候，直接使用苹果手机工厂去创建苹果手机对象，用小米手机工厂去创建小米手机对象即可。假如，我们增加需求，需要华为手机，这时只要增加一个华为工厂和华为手机的实现类即可，工厂的抽象类和手机的抽象类都不用动，符合开闭原则。

1. int main()
2. {
3.  FactoryInterface* pFactory = NULL;
4.  PhoneInterface* pPhone = NULL;
5. 
6.  //要生产一台苹果手机
7.  //先创建一个苹果手机工厂
8.  pFactory = new AppleFactory;
9.  pPhone = pFactory->production_phone();
10.   pPhone->print_brand();
11.   delete pPhone;
12.   delete pFactory;
13. 
14.   //生产一个小米手机
15.   pFactory = new XiaomiFactory;
16.   pPhone = pFactory->production_phone();
17.   pPhone->print_brand();
18.   delete pPhone;
19.   delete pFactory;
20. 
21.   system("pause");
22.   return 0;
23. }

3. 简单工厂与工厂模式对比

简单工厂模式把所有的创建逻辑都放在了一个工厂类中，而工厂模式则是提供了一个抽象的工厂接口，由具体工厂去创建产品实例，极大的方便了增加产品，删除产品等操作，且很好的符合了开闭原则，简单工厂模式每次增删产品都要直接修改工厂类，而工厂模式只需要增加一个具体工厂类和一个具体产品类就可以完成功能的扩充。

在简单工厂模式中，客户端是面向具体工厂编程，增加产品要在工厂类中修改代码；而工厂模式是面向抽象工厂编程，增加产品只要创建一个新的具体工厂就可以了，这就是面向抽象类编程。

三、抽象工厂模式

1. 什么是抽象工厂模式

Abstract Factory Pattern，抽象工厂模式。假设在前面的工厂模式下，我们对产品线提出了进一步的要求，因为手机既要在国内销售，又要在国外销售，所以同一品牌手机增加了大陆版、美版、港版等产品线。如果使用工厂模式，每一个品牌的手机，每一个版本的手机都要单独一个具体工厂来创建，很不方便‘这时候，就有了抽象工厂模式，抽象工厂模式可以创建一个产品族（包含多条产品线）。抽象工厂模式用官方语言描述就是，一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。 她也有四种角色，和工厂模式一样。

  1. 抽象工厂角色(Creator)，所有具体工厂都要实现这个接口，可以创建多个不同等级的产品（多条产品线）；
  2. 具体工厂(Concrete Creator)，负责实例化具体产品对象，多条产品线；
  3. 抽象角色(Product)，和简单工厂模式一样，它是工厂类所创建的所有实例的类的共同基类，用于描述产品的公共接口。
  4. 具体产品角色(Concrete Product)，具体工厂类所要实例化的对象。

2. 抽象工厂模式实例

首先创建一个抽象手机类 

1. //抽象产品
2. class PhoneInterface
3. {
4. public:
5.  virtual void print_brand() = 0;
6. };

根据抽象手机类定义大陆版苹果手机类，美版苹果手机类，大陆版小米手机类，美版小米手机类

1. //美版的苹果手机
2. class UsApple : public PhoneInterface
3. {
4. public:
5.  virtual void print_brand()
6.  {
7.    cout << "美版的苹果手机" << endl;
8.  }
9. };
10. 
11. //大陆版小米手机
12. class ChinaXiaomi : public PhoneInterface
13. {
14. public:
15.   virtual void print_brand()
16.   {
17.     cout << "大陆版本的小米手机" << endl;
18.   }
19. };
20. 
21. //美版的小米手机
22. class UsXiaomi : public PhoneInterface
23. {
24. public:
25.   virtual void print_brand()
26.   {
27.     cout << "美版的小米手机" << endl;
28.   }
29. };

接下来定义一个抽象工厂类，该抽象工厂类中包含两个接口，一个是苹果手机生产线，一个是小米手机生产线

1. //抽象工厂
2. class FactoryInterface
3. {
4. public:
5.  //产品线1：苹果手机
6.  virtual PhoneInterface* production_apple() = 0;
7.  //产品线2：小米手机
8.  virtual PhoneInterface* production_xiaomi() = 0;
9. };

根据抽象工厂来定义两个具体工厂，一个是大陆版手机工厂，一个是美版手机工厂

1. //生产大陆版本手机的工厂
2. class ChinaFactory : public FactoryInterface
3. {
4. public:
5.  //产品线1：苹果手机
6.  virtual PhoneInterface* production_apple()
7.  {
8.    return new ChinaApple;
9.  }
10.   //产品线2：小米手机
11.   virtual PhoneInterface* production_xiaomi()
12.   {
13.     return new ChinaXiaomi;
14.   }
15. };
16. 
17. //生产美版手机的工厂
18. class UsFactory : public FactoryInterface
19. {
20. public:
21.   //产品线1：苹果手机
22.   virtual PhoneInterface* production_apple()
23.   {
24.     return new UsApple;
25.   }
26.   //产品线2：小米手机
27.   virtual PhoneInterface* production_xiaomi()
28.   {
29.     return new UsXiaomi;
30.   }
31. };

客户可以直接使用两个具体工厂去生产大陆版苹果/小米手机或美版苹果/小米手机

1. int main()
2. {
3.  FactoryInterface* pFactory = NULL;
4.  PhoneInterface* pPhone = NULL;
5. 
6.  //使用大陆版手机的工厂
7.  cout << "======大陆版手机工厂======" << endl;
8.  pFactory = new ChinaFactory;
9.  //生产大陆版苹果手机
10.   pPhone = pFactory->production_apple();
11.   pPhone->print_brand();
12.   delete pPhone;
13.   //生产大陆版小米手机
14.   pPhone = pFactory->production_xiaomi();
15.   pPhone->print_brand();
16.   delete pPhone;
17.   delete pFactory;
18. 
19.   //使用美版手机的工厂
20.   cout << "======美版手机工厂======" << endl;
21.   pFactory = new UsFactory;
22.   pPhone = pFactory->production_apple();
23.   pPhone->print_brand();
24.   delete pPhone;
25.   pPhone = pFactory->production_xiaomi();
26.   pPhone->print_brand();
27.   delete pPhone;
28.   delete pFactory;
29. 
30.   system("pause");
31.   return 0;
32. }

3. 抽象工厂类总结

当增加一个新的产品族时，只需要增加一个新的具体工厂即可，如果整个产品族只有一个等级的产品，比如只有一条生产线，抽象工厂就和工厂模式一样了。


文章标签：
C++
设计模式
关键词：
设计模式模式
设计模式案例
C++学习笔记
设计模式简单工厂
C++案例
Mindtechnist
目录
相关文章
朝阳39
|
21小时前
|
设计模式 JavaScript 前端开发
js设计模式【详解】—— 构造函数模式
js设计模式【详解】—— 构造函数模式
朝阳39
14 6
Qiuner
|
6天前
|
设计模式 存储 算法
设计模式学习心得之五种创建者模式（2）
设计模式学习心得之五种创建者模式（2）
Qiuner
12 2
Qiuner
|
6天前
|
设计模式 安全 Java
设计模式学习心得之五种创建者模式（1）
设计模式学习心得之五种创建者模式（1）
Qiuner
7 0
米诺斯
|
6天前
|
C++
C++之员工分组案例
C++之员工分组案例
米诺斯
8 0
米诺斯
|
6天前
|
C++ 容器
C++之评委打分案例（vector与deque容器练习）
C++之评委打分案例（vector与deque容器练习）
米诺斯
9 1
米诺斯
|
6天前
|
C++
C++案例简单通讯录
C++案例简单通讯录
米诺斯
6 0
米诺斯
|
6天前
|
设计模式 搜索推荐
工厂方法模式-大话设计模式
工厂方法模式-大话设计模式
米诺斯
8 1
米诺斯
|
7天前
|
设计模式
简单工厂模式-大话设计模式
简单工厂模式-大话设计模式
米诺斯
7 0
weixin_836869520
|
12天前
|
设计模式 Java 数据库连接
Java设计模式之工厂方法模式详解
Java设计模式之工厂方法模式详解
weixin_836869520
13 1
1897697198172439
|
12天前
|
设计模式 算法
行为型设计模式之模板模式
行为型设计模式之模板模式
1897697198172439
13 1

热门文章

最新文章

  • 1
    写出易维护的代码｜React开发的设计模式及原则
  • 2
    19：Web开发模式与MVC设计模式-Java Web
  • 3
    18：JavaBean简介及其在表单处理与DAO设计模式中的应用-Java Web
  • 4
    JAVA设计模式之结构型模式
  • 5
    纯C++实现的HTTP请求封装（POST/GET）
  • 6
    Visual Studio Code搭建C++开发环境
  • 7
    c++分文件定义 深拷贝与浅拷贝
  • 8
    《C++语言基础》程序阅读——构造函数和析构函数
  • 9
    C++第10周项目4参考——完数
  • 10
    IBM RSA (IBM rational software architect ) V8 学习之三 C++类图
  • 1
    php设计模式--责任链模式（五）
    19
  • 2
    php设计模式--装饰模式（七）装饰模式完成文章编辑
    15
  • 3
    设计模式了解哪些，模版模式
    34
  • 4
    23种设计模式，命令模式的概念优缺点以及JAVA代码举例
    35
  • 5
    设计模式 - 观察者模式（Observer）：Java中的战术与策略
    53
  • 6
    分析设计模式对Java应用性能的影响，并提供优化策略
    21
  • 7
    设计模式揭秘：Java世界的七大奇迹
    21
  • 8
    23种设计模式，适配器模式的概念优缺点以及JAVA代码举例
    51
  • 9
    23种设计模式，抽象工厂模式的概念优缺点以及JAVA代码举例
    47
  • 10
    【分布式技术专题】「Tomcat技术专题」 探索Tomcat技术架构设计模式的奥秘（Server和Service组件原理分析）
    62

    • 相关课程

    更多
  • C++ 入门教程开发文档
  • 5天玩转Java面向对象编程
  • Java面向对象编程
  • Java面向对象开发

    • 相关电子书

    更多
  • 使用C++11开发PHP7扩展
  • GPON Class C++ SFP O;T Transce
  • GPON Class C++ SFP OLT Transce
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）