1.简单工厂模式

1.1 定义

定义一个工厂类，他可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。

1.2 优点

  1. 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责。
  2. 客户端无需知道所创建具体产品的类名，只需知道参数即可。

  3. 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。

    1.3 缺点

  4. 工厂类集中了所有产品的创建逻辑，职责过重，一旦异常，整个系统将受影响。

  5. 使用简单工厂模式会增加系统中类的个数(引入新的工厂类)，增加系统的复杂度和理解难度。
  6. 系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂。

  7. 简单工厂模式使用了static工厂方法，造成工厂角色无法形成基于继承的等级结构。

    1.4 使用场景

  8. 工厂类负责创建对的对象比较少，因为不会造成工厂方法中的业务逻辑过于复杂。

  9. 客户端只知道传入工厂类的参数，对如何创建对象不关心。

    1.5 类图及示例代码

    2. 工厂模式 - 图1 ```cpp // 简单工厂模式

    include

using namespace std;

// 怪物父类 class Monster { public: Monster(int life, int magic, int attack) : E_life(life) , E_magic(magic) , E_attack(attack) { } // 做父类时析构函数应该为虚函数 virtual ~Monster() = default;

private: // 怪物属性 int E_life; // 生命值 int E_magic; // 魔法 int E_attack; // 攻击力 };

// 亡灵类怪物 class Undead : public Monster { public: Undead(int life, int magic, int attack) : Monster(life, magic, attack) { cout << “A undead monster came into the world.” << endl; } // 其它逻辑代码 ~Undead() override = default; };

// 元素类怪物 class Element : public Monster { public: Element(int life, int magic, int attack) : Monster(life, magic, attack) { cout << “A element monster came into the world.” << endl; } // 其它逻辑代码 ~Element() override = default; };

// 机械类怪物 class Mechanic : public Monster { public: Mechanic(int life, int magic, int attack) : Monster(life, magic, attack) { cout << “A mechanic monster came into the world.” << endl; } // 其他逻辑代码 ~Mechanic() override = default; };

// 静态工厂 class StaticMonsterFactory { public: enum MonsterType { E_Undead, E_Element, E_Mechanic };

  1. static Monster* CreateMonster(MonsterType type)
  2. {
  3.     Monster* monster = nullptr;
  4.     if (type == E_Undead) { // 亡灵类
  5.         monster = new Undead(300, 50, 60);
  6.     } else if (type == E_Element) { // 元素类
  7.         monster = new Element(200, 80, 100);
  8.     } else if (type == E_Mechanic) { // 机械类
  9.         monster = new Mechanic(400, 0, 110);
  10.     }
  11.     return monster;
  12. }

};

void simple_factory() { std::cout << “simple factory” << std::endl; { // 不创建 Monster monster1 = new Undead(300, 50, 80); Monster monster2 = new Element(200, 50, 100); Monster* monster3 = new Mechanic(400, 0, 110);

  1.     delete monster1;
  2.     delete monster2;
  3.     delete monster3;
  4. }
  5. { // 使用工厂类
  6.     Monster* monster1 = StaticMonsterFactory::CreateMonster(StaticMonsterFactory::E_Undead);
  7.     Monster* monster2 = StaticMonsterFactory::CreateMonster(StaticMonsterFactory::E_Element);
  8.     Monster* monster3 = StaticMonsterFactory::CreateMonster(StaticMonsterFactory::E_Mechanic);
  10.     delete monster1;
  11.     delete monster2;
  12.     delete monster3;
  13. }

}

  2. <a name="fTji8"></a>
  3. ### 2.工厂模式
  4. <a name="rMk3a"></a>
  5. #### 2.1 定义
  6. 定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
  7. <a name="ZaWPw"></a>
  8. #### 2.2 优点
  10. 1. 一个调用者想创建一个对象，只要知道其名称就可以了。
  11. 1. 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
  12. 1. 屏蔽产品的具体实现，调用者只关心产品的接口。
  13. <a name="g7CYM"></a>
  14. #### 2.3 缺点
  15. 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
  16. <a name="fj9JR"></a>
  17. #### 2.4 使用场景
  19. 1. 日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 
  20. 1. 数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 
  21. 1. 设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。
  22. <a name="oW6y3"></a>
  23. #### 2.5 类图及示例代码
  24. ![](https://cdn.nlark.com/yuque/0/2021/svg/2878535/1627193991851-75051778-8cfd-43c6-b86d-812e5a3dcf0e.svg#crop=0&crop=0&crop=1&crop=1&from=url&id=X4lfu&margin=%5Bobject%20Object%5D&originHeight=611&originWidth=713&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
  25. ```cpp
  26. // 怪物父类
  27. class Monster {
  28. public:
  29.     Monster(int life, int magic, int attack)
  30.         : m_life(life)
  31.         , m_magic(magic)
  32.         , m_attack(attack)
  33.     {
  34.     }
  35.     // 做父类时析构函数应该为虚函数
  36.     virtual ~Monster() = default;
  38. protected:
  39.     int m_life; // 生命值
  40.     int m_magic; // 魔法值
  41.     int m_attack; // 攻击力
  42. };
  44. // 亡灵类怪物
  45. class Undead : public Monster {
  46. public:
  47.     Undead(int life, int magic, int attack)
  48.         : Monster(life, magic, attack)
  49.     {
  50.         cout << "A undead monster came into the world." << endl;
  51.     }
  52.     // 其他代码略...
  53.     ~Undead() override = default;
  54. };
  56. // 元素类怪物
  57. class Element : public Monster {
  58. public:
  59.     Element(int life, int magic, int attack)
  60.         : Monster(life, magic, attack)
  61.     {
  62.         cout << "A element monster came into the world." << endl;
  63.     }
  64.     // 其他代码略...
  65.     ~Element() override = default;
  66. };
  68. // 机械类怪物
  69. class Mechanic : public Monster {
  70. public:
  71.     Mechanic(int life, int magic, int attack)
  72.         : Monster(life, magic, attack)
  73.     {
  74.         cout << "A mechanic monster came into the world." << endl;
  75.     }
  76.     // 其他代码略...
  77.     ~Mechanic() override = default;
  78. };
  79. // 怪物工厂父类
  80. class MonsterFactory {
  81. public:
  82.     virtual Monster* CreateMonster() = 0;
  83.     virtual ~MonsterFactory() = default;
  84. };
  86. // 亡灵类工厂类
  87. class UndeadFactor : public MonsterFactory {
  88. public:
  89.     Monster* CreateMonster() override
  90.     {
  91.         // 创建亡灵类怪物
  92.         return new Undead(300, 50, 80);
  93.     }
  94. };
  96. // 元素类工厂类
  97. class ElementFactor : public MonsterFactory {
  98. public:
  99.     Monster* CreateMonster() override
  100.     {
  101.         // 创建元素类怪物
  102.         return new Element(300, 50, 80);
  103.     }
  104. };
  106. // 机械类工厂类
  107. class MechanicFactor : public MonsterFactory {
  108. public:
  109.     Monster* CreateMonster() override
  110.     {
  111.         // 创建机械类怪物
  112.         Monster* temp = new Mechanic(300, 50, 80);
  113.         return temp;
  114.     }
  115. };
  117. // 1.全局的用于创建怪物对象的函数,注意形参的类型是工厂父类类型的指针
  118. Monster* globalCreateMonster(MonsterFactory* factory)
  119. {
  120.     // 该虚函数扮演了多态new的行为,factory指向的具体怪物工厂类不同,创建的怪物对象也不同
  121.     return factory->CreateMonster();
  122. }
  124. // 2.封装工厂子类模板
  125. template <typename T>
  126. class ChildFactory : public MonsterFactory {
  127. public:
  128.     Monster* CreateMonster() override
  129.     {
  130.         return new T(300, 50, 80);
  131.     }
  132. };
  134. void FactoryMethod()
  135. {
  136.     {
  137.         // 产生亡灵类怪物
  138.         MonsterFactory* undeadFactor = new UndeadFactor();
  139.         Monster* undead = globalCreateMonster(undeadFactor);
  140.         // 产生元素类怪物
  141.         MonsterFactory* elementFactor = new ElementFactor();
  142.         Monster* element = globalCreateMonster(elementFactor);
  143.         // 产生机械类怪物
  144.         MonsterFactory* mechanicFactor = new MechanicFactor();
  145.         Monster* mechanic = globalCreateMonster(mechanicFactor);
  147.         delete undeadFactor;
  148.         delete undead;
  149.         delete elementFactor;
  150.         delete element;
  151.         delete mechanicFactor;
  152.         delete mechanic;
  153.     }
  154.     { 
  155.         // 封装怪物子类
  156.         ChildFactory<Undead> undeadFactory;
  157.         Monster* undead = undeadFactory.CreateMonster();
  158.         delete undead;
  159.     }
  160. }

3.抽象工厂模式

3.1 定义

  • 抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。
  • 抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。
  • 抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。
  • 根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。

    3.2 优点

    当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

    3.3 缺点

    产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

    3.4 使用场景

  1. QQ 换皮肤，一整套一起换。
  2. 生成不同操作系统的程序。

    3.5 类图及示例代码

    生产怪物范例抽象工厂模式示意图
    image.png

2. 工厂模式 - 图3

  1. #include <iostream>
  2. using namespace std;
  5. // 怪物父类
  6. class Monster {
  7. public:
  8.     Monster(int life, int magic, int attack)
  9.         : m_life(life)
  10.         , m_magic(magic)
  11.         , m_attack(attack)
  12.     {
  13.     }
  14.     // 做父类时析构函数应该为虚函数
  15.     virtual ~Monster() = default;
  17. protected:
  18.     int m_life; // 生命值
  19.     int m_magic; // 魔法值
  20.     int m_attack; // 攻击力
  21. };
  23. // 沼泽地区亡灵类怪物
  24. class SwampUndead : public Monster {
  25. public:
  26.     SwampUndead(int life, int magic, int attack)
  27.         : Monster(life, magic, attack)
  28.     {
  29.         cout << "A swamp undead monster came into the world." << endl;
  30.     }
  31.     // 其他代码略...
  32.     ~SwampUndead() override = default;
  33. };
  35. // 沼泽地区元素类怪物
  36. class SwampElement : public Monster {
  37. public:
  38.     SwampElement(int life, int magic, int attack)
  39.         : Monster(life, magic, attack)
  40.     {
  41.         cout << "A swamp element monster came into the world." << endl;
  42.     }
  43.     // 其他代码略...
  44.     ~SwampElement() override = default;
  45. };
  47. // 沼泽地区机械类怪物
  48. class SwampMechanic : public Monster {
  49. public:
  50.     SwampMechanic(int life, int magic, int attack)
  51.         : Monster(life, magic, attack)
  52.     {
  53.         cout << "A swamp mechanic monster came into the world." << endl;
  54.     }
  55.     // 其他代码略...
  56.     ~SwampMechanic() override = default;
  57. };
  59. // 山脉亡灵类怪物
  60. class MountainUndead : public Monster {
  61. public:
  62.     MountainUndead(int life, int magic, int attack)
  63.         : Monster(life, magic, attack)
  64.     {
  65.         cout << "A mountain undead monster came into the world." << endl;
  66.     }
  67.     // 其他代码略...
  68.     ~MountainUndead() override = default;
  69. };
  71. // 山脉元素类怪物
  72. class MountainElement : public Monster {
  73. public:
  74.     MountainElement(int life, int magic, int attack)
  75.         : Monster(life, magic, attack)
  76.     {
  77.         cout << "A mountain element monster came into the world." << endl;
  78.     }
  79.     // 其他代码略...
  80.     ~MountainElement() override = default;
  81. };
  83. // 山脉机械类怪物
  84. class MountainMechanic : public Monster {
  85. public:
  86.     MountainMechanic(int life, int magic, int attack)
  87.         : Monster(life, magic, attack)
  88.     {
  89.         cout << "A mountain mechanic monster came into the world." << endl;
  90.     }
  91.     // 其他代码略...
  92.     ~MountainMechanic() override = default;
  93. };
  95. // 城镇亡灵类怪物
  96. class TownUndead : public Monster {
  97. public:
  98.     TownUndead(int life, int magic, int attack)
  99.         : Monster(life, magic, attack)
  100.     {
  101.         cout << "A town undead monster came into the world." << endl;
  102.     }
  103.     // 其他代码略...
  104.     ~TownUndead() override = default;
  105. };
  107. // 山脉元素类怪物
  108. class TownElement : public Monster {
  109. public:
  110.     TownElement(int life, int magic, int attack)
  111.         : Monster(life, magic, attack)
  112.     {
  113.         cout << "A town element monster came into the world." << endl;
  114.     }
  115.     // 其他代码略...
  116.     ~TownElement() override = default;
  117. };
  119. // 山脉机械类怪物
  120. class TownMechanic : public Monster {
  121. public:
  122.     TownMechanic(int life, int magic, int attack)
  123.         : Monster(life, magic, attack)
  124.     {
  125.         cout << "A town mechanic monster came into the world." << endl;
  126.     }
  127.     // 其他代码略...
  128.     ~TownMechanic() override = default;
  129. };
  131. // 所有工厂类的父类
  132. class MonsterFactory {
  133. public:
  134.     // 创建亡灵类怪物
  135.     virtual Monster* createMonsterUndead() = 0;
  136.     // 创建元素类怪物
  137.     virtual Monster* createMonsterElement() = 0;
  138.     // 创建机械类怪物
  139.     virtual Monster* createMonsterMechanic() = 0;
  140.     // 做父类时析构函数应该为虚函数
  141.     virtual ~MonsterFactory() = default;
  142. };
  144. // 沼泽地区工厂类
  145. class SwapFactory : public MonsterFactory {
  146. public:
  147.     // 创建沼泽地区亡灵类怪物
  148.     Monster* createMonsterUndead() override
  149.     {
  150.         return new SwampUndead(300, 50, 120);
  151.     };
  152.     // 创建沼泽地区元素类怪物
  153.     Monster* createMonsterElement() override
  154.     {
  155.         return new SwampElement(200, 80, 110);
  156.     };
  157.     // 创建沼泽地区机械类怪物
  158.     Monster* createMonsterMechanic() override
  159.     {
  160.         return new SwampMechanic(400, 0, 90);
  161.     };
  162.     ~SwapFactory() override = default;
  163. };
  165. // 山脉地区工厂类
  166. class MountainFactory : public MonsterFactory {
  167. public:
  168.     // 创建山脉地区亡灵类怪物
  169.     Monster* createMonsterUndead() override
  170.     {
  171.         return new MountainUndead(300, 50, 80);
  172.     };
  173.     // 创建山脉地区元素类怪物
  174.     Monster* createMonsterElement() override
  175.     {
  176.         return new MountainElement(200, 80, 100);
  177.     };
  178.     // 创建山脉地区机械类怪物
  179.     Monster* createMonsterMechanic() override
  180.     {
  181.         return new MountainMechanic(600, 0, 90);
  182.     };
  183.     ~MountainFactory() override = default;
  184. };
  186. // 城镇地区工厂类
  187. class TownFactory : public MonsterFactory {
  188. public:
  189.     // 创建城镇地区亡灵类怪物
  190.     Monster* createMonsterUndead() override
  191.     {
  192.         return new TownUndead(300, 50, 120);
  193.     };
  194.     // 创建城镇地区元素类怪物
  195.     Monster* createMonsterElement() override
  196.     {
  197.         return new TownElement(200, 80, 110);
  198.     };
  199.     // 创建城镇地区机械类怪物
  200.     Monster* createMonsterMechanic() override
  201.     {
  202.         return new TownMechanic(400, 0, 90);
  203.     };
  204.     ~TownFactory() override = default;
  205. };
  207. void AbstractFactory()
  208. {
  209.     // 多态工厂, 山脉地区的工厂
  210.     MonsterFactory* mountainFactory = new MountainFactory();
  211.     // 创建山脉地区的元素类怪物、亡灵类怪物
  212.     Monster* mountainElementMonster = mountainFactory->createMonsterElement();
  213.     Monster* mountainUndeadMonster = mountainFactory->createMonsterUndead();
  215.     // 多态工厂,沼泽地区的工厂
  216.     MonsterFactory* swampFactory = new SwapFactory();
  217.     // 创建山脉地区的元素类怪物、亡灵类怪物
  218.     Monster* swampElementMonster = swampFactory->createMonsterElement();
  219.     Monster* swampUndeadMonster = swampFactory->createMonsterUndead();
  221.     delete mountainFactory;
  222.     delete mountainElementMonster;
  223.     delete mountainUndeadMonster;
  224.     delete swampFactory;
  225.     delete swampElementMonster;
  226.     delete swampUndeadMonster;
  227. }