简单工厂方法模式之“构造函数和析构函数”理解

迈不过友情╰ 2022-11-14 14:40 185阅读 0赞

reference: https://blog.csdn.net/weixin\_46826913/article/details/106289647
简单工厂模式（C语言实现）
简单工厂、工厂方法模式、抽象工厂模式
C++ 类构造函数 & 析构函数

使用C语言的来模拟C++中的面向对象概念。

1 简介

简单工厂方法定义一个用于创建对象的类，该类接受一个参数，通过参数决定创建不同的对象。

GOF并没有把简单工厂方法定义为23种设计模式之一，可以认为简单工厂方法是工厂方法的简化形式。

为了体现简单工厂方法和工厂方法的区别和联系，此处把简单工厂方法先单独讲一下。

2 模拟场景

假设你要生产电脑，电脑由硬盘、内存条、CPU、主板的部件组成。你为了保证供应链可靠，每种部件都选择了至少两家供应商。比如：

  1. 硬盘供应商 seagate、Toshiba
  2. 内存条供应商 SAMSUNG、Crucial
  3. CPU供应商 intel、AMD
  4. 主板供应商 intel、AMD

此处列出多个部件是为了后面讲解工厂方法、抽象工厂方法时使用同一个模拟场景。本章讲简单工厂方法暂时不需要涉及这么多部件，所以仅以硬盘这一个部件为例进行讲解。

3 使用简单工厂方法实现的思路

硬盘就是要创建的对象（即：产品）。为了让不同供应商提供的硬盘可以通用，要定义一个硬盘产品类，并让不同供应商的硬盘都继承硬盘产品类的接口。

还需要定义一个创建硬盘对象的类（即：工厂）。工厂类根据参数决定创建哪家供应商的硬盘对象。

4 使用简单工厂方法实现硬盘对象创建

参与者

Product: HardDisk
定义硬盘对象的接口

Concrete Product: SeagateHardDisk, ToshibaHardDisk
实现不同供应商的硬盘

SimpleFactory: HardDiskFactory
根据参数，创建不同供应商的硬盘对象

UML:在这里插入图片描述
HardDisk代码示例

hard_disk.h

  1. #ifndef HARD_DISK_H
  2. #define HARD_DISK_H
  4. struct HardDisk {
  5.     void (*Operation)(struct HardDisk *this);
  6. };
  8. #endif

SeagateHardDisk代码示例

  1. seagate_hard_disk.h
  3. #ifndef SEAGATE_HARD_DISK_H
  4. #define SEAGATE_HARD_DISK_H
  6. #include "hard_disk.h"
  8. struct SeagateHardDisk {
  9.     struct HardDisk hardDisk;
  10. };
  12. // 构造函数
  13. void SeagateHardDisk(struct SeagateHardDisk *this);
  15. // 析构函数
  16. void _SeagateHardDisk(struct SeagateHardDisk *this);
  18. #endif

seagate_hard_disk.c

  1. #include "seagate_hard_disk.h"
  2. #include "stdio.h"
  4. void SeagateOperation(struct SeagateHardDisk *this)
  5. {
  6.     printf("这是 Seagate 硬盘\n");
  7. }
  9. void SeagateHardDisk(struct SeagateHardDisk *this)
  10. {
  11.     this->hardDisk.Operation = (void(*)(struct HardDisk *))SeagateOperation;
  12. }
  14. void _SeagateHardDisk(struct SeagateHardDisk *this)
  15. {
  16.     this->hardDisk.Operation = NULL;
  17. }

ToshibaHardDisk代码示例

toshiba_hard_disk.h

  1. #ifndef TOSHIBA_HARD_DISK_H
  2. #define TOSHIBA_HARD_DISK_H
  4. #include "hard_disk.h"
  6. struct ToshibaHardDisk {
  7.     struct HardDisk hardDisk;
  8. };
  10. // 构造函数
  11. void ToshibaHardDisk(struct ToshibaHardDisk *this);
  13. // 析构函数
  14. void _ToshibaHardDisk(struct ToshibaHardDisk *this);
  16. #endif

toshiba_hard_disk.c

  1. #include "toshiba_hard_disk.h"
  2. #include "stdio.h"
  4. void ToshibaOperation(struct ToshibaHardDisk *this)
  5. {
  6.     printf("这是 Toshiba 硬盘\n");
  7. }
  9. void ToshibaHardDisk(struct ToshibaHardDisk *this)
  10. {
  11.     this->hardDisk.Operation = (void(*)(struct HardDisk *))ToshibaOperation;
  12. }
  14. void _ToshibaHardDisk(struct ToshibaHardDisk *this)
  15. {
  16.     this->hardDisk.Operation = NULL;
  17. }

HardDiskFactory代码示例

  1. hard_disk_factory.h
  3. #ifndef HARD_DISK_FACTORY_H
  4. #define HARD_DISK_FACTORY_H
  6. #include "hard_disk.h"
  8. enum HARD_DISK_SUPPLIER_E {
  9.     HARD_DISK_SUPPLIER_SEAGATE,
  10.     HARD_DISK_SUPPLIER_TOSHIBA
  11. };
  13. struct HardDiskFactory {
  14.     struct HardDisk* (*Create)(struct HardDiskFactory *this, 
  15.                                enum HARD_DISK_SUPPLIER_E supplier);
  16.     void (*Destroy)(struct HardDiskFactory *this, 
  17.                     struct HardDisk* hardDisk);
  18. };
  20. // 构造函数
  21. void HardDiskFactory(struct HardDiskFactory *this);
  23. // 析构函数
  24. void _HardDiskFactory(struct HardDiskFactory *this);
  26. #endif

hard_disk_factory.c

  1. #include "hard_disk_factory.h"
  2. #include "seagate_hard_disk.h"
  3. #include "toshiba_hard_disk.h"
  4. #include "stdio.h"
  5. #include "stdlib.h"
  7. struct HardDisk *Create(struct HardDiskFactory *this, 
  8.                         enum HARD_DISK_SUPPLIER_E supplier) 
  9. {
  10.     switch (supplier) {
  11.         case HARD_DISK_SUPPLIER_SEAGATE:
  12.         {
  13.             struct SeagateHardDisk *seagateHardDisk = NULL;
  14.             if ((seagateHardDisk = malloc(sizeof(struct SeagateHardDisk))) == NULL) {
  15.                 printf("fail in malloc\n");
  16.                 return NULL;
  17.             }
  18.             SeagateHardDisk(seagateHardDisk);
  19.             return (struct HardDisk *)seagateHardDisk;
  20.         }
  21.         case HARD_DISK_SUPPLIER_TOSHIBA:
  22.         {
  23.             struct ToshibaHardDisk *toshibaHardDisk = NULL;
  24.             if ((toshibaHardDisk = malloc(sizeof(struct ToshibaHardDisk))) == NULL) {
  25.                 printf("fail in malloc\n");
  26.                 return NULL;
  27.             }
  28.             ToshibaHardDisk(toshibaHardDisk);
  29.             return (struct HardDisk *)toshibaHardDisk;
  30.         }
  31.         default:
  32.             printf("未知的供应商\n");
  33.             return NULL;
  34.     }
  35. }
  37. void Destroy(struct HardDiskFactory *this, struct HardDisk* hardDisk)
  38. {
  39.     if (hardDisk != NULL) {
  40.         free(hardDisk);
  41.     }
  42. }
  44. // 构造函数
  45. void HardDiskFactory(struct HardDiskFactory *this)
  46. {
  47.     this->Create = Create;
  48.     this->Destroy = Destroy;
  49. }
  51. // 析构函数
  52. void _HardDiskFactory(struct HardDiskFactory *this)
  53. {
  54.     this->Create = NULL;
  55.     this->Destroy = NULL;
  56. }

客户端代码示例

  1. #include "hard_disk.h"
  2. #include "hard_disk_factory.h"
  3. #include "stddef.h"
  5. void main()
  6. {
  7.     struct HardDisk *hardDisk = NULL;
  9.     struct HardDiskFactory hardDiskFactory;
  10.     HardDiskFactory(&hardDiskFactory);
  12.     // 创建 seagate 硬盘对象
  13.     hardDisk = hardDiskFactory.Create(&hardDiskFactory, HARD_DISK_SUPPLIER_SEAGATE);
  14.     // 使用 seagate 硬盘对象
  15.     hardDisk->Operation(hardDisk);  
  16.     // 销毁 seagate 硬盘对象
  17.     hardDiskFactory.Destroy(&hardDiskFactory, hardDisk);       
  19.     // 创建 toshiba 硬盘对象
  20.     hardDisk = hardDiskFactory.Create(&hardDiskFactory, HARD_DISK_SUPPLIER_TOSHIBA);
  21.     // 使用 seagate 硬盘对象
  22.     hardDisk->Operation(hardDisk);
  23.     // 销毁 toshiba 硬盘对象
  24.     hardDiskFactory.Destroy(&hardDiskFactory, hardDisk);    
  26.     _HardDiskFactory(&hardDiskFactory);
  27. }

客户端显示示例

  1. ./hard_disk
  2. 这是 Seagate 硬盘
  3. 这是 Toshiba 硬盘

发表评论

表情：
评论列表 （有 0 条评论，185人围观）

还没有评论，来说两句吧...

相关阅读

    相关 C#之析构函数与构造函数

          在学习C\时这两个函数放到一起讲了，听课的时候感觉只是有了肤浅的认识，于是查了一些资料，下面做个比较全面的理解。       析构函数——垃圾回收器，它用来清理

    梦里梦外;梦里梦外;/ 0 赞/ 400 阅读

    相关 C++ 构造函数和析构函数

    百度百科：构造函数 ，是一种特殊的方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。特别的一个类可以有多个构造函数

    野性酷女野性酷女/ 0 赞/ 518 阅读

    相关 使用构造函数和析构函数

    构造函数和析构函数控制对象的创建和毁坏。 若要为类创建构造函数，请在类定义的任何位置创建名为 Sub New 的过程。若要创建参数化构造函数，请像为其他任何过程指定参数那样为

    Myth丶恋晨Myth丶恋晨/ 0 赞/ 597 阅读