new 创建的是堆对象，可以实现多态。
工厂模式：通过把创建对象的代码包装起来，做到创建对象的代码与具体的业务逻辑代码相隔离的目的。

工厂模式细分：

  • 简单工厂模式
  • 工厂方法模式
  • 抽象工厂模式

面对对象程序设计一个重要原则：开闭原则

一、简单工厂模式 Simple Factory

1.1 功能策划

  • 怪物分类：亡灵类怪物、元素类怪物、机械类怪物
  • 共有属性：生命值、魔法值、攻击力
  • Monster作为父类，Undead(亡灵类)、Element(元素类)、Mechanic(机械类)

    1.2 示例代码一(未引入工厂类)

    ```cpp

    include

using namespace std; // 怪物父类 class Monster { public: Monster(int life, int magic, int attack) : m_life(life) , m_magic(magic) , m_attack(attack) { } // 做父类时析构函数应该为虚函数 virtual ~Monster() { }

protected: // 怪兽属性 int m_life; // 生命值 int m_magic; // 魔法值 int m_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; } // 其他逻辑代码

  1. ~Undead() { }

};

// 元素类怪物 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; } // 其他逻辑代码

  1. ~Element() { }

}; // 机械类怪物 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; } // 其他逻辑代码

  1. ~Mechanic() { }

};

int main(int argc, char argv[]) { Monster pM1 = new Undead(300, 50, 80); Monster pM2 = new Element(200, 50, 100); Monster pM3 = new Mechanic(400, 0, 110);

  1. delete pM1;
  2. delete pM2;
  3. delete pM3;

}

  1. 当游戏内容增加更多的怪物，需要创建更多对象，改变可能较大不方便维护。
  3. 即：
  5. - 使用new + 具体类名来创建一种依赖具体类型的紧耦合关系
  6. - 使用工厂类 **实现创建怪物的代码** 与 **各个具体怪物类对象要实现的逻辑 **代码隔离
  7. - 封装变化：把依赖范围尽可能缩小，把容易变化的代码段限制在一个小范围内，就可以在很大程度上提高代码的可维护性和可扩展性
  8. - **通过增加新的 if...else..分支来达到支持新怪物增加的目的 -- 违背了面向对象程序设计的原则 -- 开闭原则**
  10. 开闭原则
  12. - 说的是代码扩展性问题 -- 对扩展开放，对修改关闭（封闭）
  13. - **当增加新功能，不应该通过修改已经存在的代码来进行，而是应该通过扩展代码(比如增加新类，增加新成员函数)来进行**
  17. **如果 if..else..分支不多(没有数十上百个)，则适当违法开闭原则是可以接受的。需要在可读性和可扩展性之间做出权衡**
  18. <a name="LgsqM"></a>
  19. ## 1.3 引入简单工厂模式
  21. 引入简单工厂模式的定义（实现意图：定义一个工厂类(MonsterFactory)，该类的成员函数(`createMonster()`)可以根据不同参数创建并返回不同的类对象，被创建的对象所属的类(Undead，Element，Mechanic)一般都具有相同的父类(Monster)，调用者无需关心创建对象的细节。
  23. 简单工厂方法模式：实现了创建怪物类代码(`createMonster()`)，与具体怪物类(Undead，Element，Mechanic)解耦合
  25. <a name="xnygb"></a>
  26. ## 1.4 示例代码二(创建工厂类后)
  27. ```cpp
  28. #include <iostream>
  30. using namespace std;
  32. // 怪物父类
  33. class Monster {
  34. public:
  35.     // 构造函数
  36.     Monster(int life, int magic, int attack)
  37.         : m_life(life)
  38.         , m_magic(magic)
  39.         , m_attack(attack)
  40.     {
  41.     }
  42.     // 做父类时析构函数应该为虚函数
  43.     virtual ~Monster() { }
  45. protected:
  46.     int m_life; // 生命值
  47.     int m_magic; // 魔法值
  48.     int m_attack; // 攻击力
  49. };
  51. // 亡灵类怪物
  52. class Undead : public Monster {
  53. public:
  54.     Undead(int life, int magic, int attack)
  55.         : Monster(life, magic, attack)
  56.     {
  57.         cout << "A undead monster came into the world." << endl;
  58.     }
  59.     // 其他代码略...
  60.     ~Undead() { }
  61. };
  63. // 元素类怪物
  64. class Element : public Monster {
  65. public:
  66.     Element(int life, int magic, int attack)
  67.         : Monster(life, magic, attack)
  68.     {
  69.         cout << "A element monster came into the world." << endl;
  70.     }
  71.     // 其他代码略...
  72.     ~Element() { }
  73. };
  75. // 机械类怪物
  76. class Mechanic : public Monster {
  77. public:
  78.     Mechanic(int life, int magic, int attack)
  79.         : Monster(life, magic, attack)
  80.     {
  81.         cout << "A mechanic monster came into the world." << endl;
  82.     }
  83.     // 其他代码略...
  84.     ~Mechanic() { }
  85. };
  87. // 怪物工厂类-1
  88. class MonsterFactory {
  89. public:
  90.     Monster* createMonster(string monsterType)
  91.     {
  92.         Monster* monster = nullptr;
  93.         if (monsterType == "undead") { // 亡灵类
  94.             monster = new Undead(300, 50, 60);
  95.         }
  96.         else if (monsterType == "element") { // 元素类
  97.             monster = new Element(200, 80, 100);
  98.         }
  99.         else if (monsterType == "mechanic") { // 机械类
  100.             monster = new Mechanic(400, 0, 110);
  101.         }
  102.         return monster;
  103.     }
  104. };
  106. // 静态怪物工厂类
  107. class StaticMonsterFactory {
  108. public:
  109.     static Monster* createMonster(string monsterType)
  110.     {
  111.         Monster* monster = nullptr;
  112.         if (monsterType == "undead") { // 亡灵类
  113.             monster = new Undead(300, 50, 60);
  114.         }
  115.         else if (monsterType == "element") { // 元素类
  116.             monster = new Element(200, 80, 100);
  117.         }
  118.         else if (monsterType == "mechanic") { // 机械类
  119.             monster = new Mechanic(400, 0, 110);
  120.         }
  121.         return monster;
  122.     }
  123. };
  125. void simpleFactorMode()
  126. {
  127.     {
  128.         MonsterFactory monsterFactory; // 需要知道每个怪物对应的枚举值或者字符串
  129.         // 产生一只亡灵类怪物
  130.         Monster* p_undead = monsterFactory.createMonster("undead");
  131.         // 产生一只元素类怪物
  132.         Monster* p_element = monsterFactory.createMonster("element");
  133.         // 产生一只机械类怪物
  134.         Monster* p_mechanic = monsterFactory.createMonster("mechanic");
  136.         // 释放资源
  137.         delete p_undead;
  138.         delete p_element;
  139.         delete p_mechanic;
  140.     }
  141.     cout << endl;
  142.     {   // 静态怪物工厂类
  143.         // 产生一只亡灵类怪物
  144.         Monster* p_undead = StaticMonsterFactory::createMonster("undead");
  145.         // 产生一只元素类怪物
  146.         Monster* p_element = StaticMonsterFactory::createMonster("element");
  147.         // 产生一只机械类怪物
  148.         Monster* p_mechanic = StaticMonsterFactory::createMonster("mechanic");
  150.         // 释放资源
  151.         delete p_undead;
  152.         delete p_element;
  153.         delete p_mechanic;
  154.     }
  155. }

1.5 类图

5.简单工厂模式.svg

二、工厂方法模式 Factory Method

2.1 引入工厂方法模式

与简单工厂模式比，灵活性更强，实现也更加复杂，引入更多的新类。

UndeadFactory、ElementFactory、MechanicFactory类，有一个共同的父类MasterFactory（工厂抽象类）。

符合开闭原则，付出的代价是需要新增加多个新的工厂类。

2.2 示例代码

  1. #include <iostream>
  3. using namespace std;
  5. // 怪物父类
  6. class Monster {
  7. public:
  8.     // 构造函数
  9.     Monster(int life, int magic, int attack)
  10.         : m_life(life)
  11.         , m_magic(magic)
  12.         , m_attack(attack)
  13.     {
  14.     }
  15.     // 做父类时析构函数应该为虚函数
  16.     virtual ~Monster() { }
  18. protected:
  19.     int m_life; // 生命值
  20.     int m_magic; // 魔法值
  21.     int m_attack; // 攻击力
  22. };
  24. // 亡灵类怪物
  25. class Undead : public Monster {
  26. public:
  27.     Undead(int life, int magic, int attack)
  28.         : Monster(life, magic, attack)
  29.     {
  30.         cout << "A undead monster came into the world." << endl;
  31.     }
  32.     // 其他代码略...
  33.     ~Undead() { }
  34. };
  36. // 元素类怪物
  37. class Element : public Monster {
  38. public:
  39.     Element(int life, int magic, int attack)
  40.         : Monster(life, magic, attack)
  41.     {
  42.         cout << "A element monster came into the world." << endl;
  43.     }
  44.     // 其他代码略...
  45.     ~Element() { }
  46. };
  48. // 机械类怪物
  49. class Mechanic : public Monster {
  50. public:
  51.     Mechanic(int life, int magic, int attack)
  52.         : Monster(life, magic, attack)
  53.     {
  54.         cout << "A mechanic monster came into the world." << endl;
  55.     }
  56.     // 其他代码略...
  57.     ~Mechanic() { }
  58. };
  60. // 怪物工厂父类
  61. class MonsterFactory {
  62. public:
  63.     // 具体的实现在子类中进行
  64.     virtual Monster* createMonster() = 0;
  65.     // 做父类时析构函数应该为虚函数
  66.     virtual ~MonsterFactory() {};
  67. };
  69. // 亡灵类工厂类
  70. class UndeadFactor : public MonsterFactory {
  71. public:
  72.     Monster* createMonster() override
  73.     {
  74.         // 创建亡灵类怪物
  75.         Monster* temp = new Undead(300, 50, 80);
  76.         // return new Undead(300, 50, 80);
  77.         return temp;
  78.     }
  79. };
  81. // 元素类工厂类
  82. class ElementFactor : public MonsterFactory {
  83. public:
  84.     Monster* createMonster() override
  85.     {
  86.         // 创建元素类怪物
  87.         Monster* temp = new Element(300, 50, 80);
  88.         return temp;
  89.     }
  90. };
  92. // 机械类工厂类
  93. class MechanicFactor : public MonsterFactory {
  94. public:
  95.     Monster* createMonster() override
  96.     {
  97.         // 创建机械类怪物
  98.         Monster* temp = new Mechanic(300, 50, 80);
  99.         return temp;
  100.     }
  101. };
  103. // 全局的用于创建怪物对象的函数,注意形参的类型是工厂父类类型的指针,返回类型是怪物父类的指针
  104. Monster* globalCreateMonster(MonsterFactory* factory)
  105. {
  106.     return factory->createMonster(); // 该虚函数扮演了多态new的行为,factory指向的具体怪物工厂类不同,创建的怪物对象也不同
  107. }
  109. // 不想创建太多工厂类,又想封装变化
  110. // 创建怪物工厂子类模板
  111. template <typename T>
  112. class ChildFactory : public MonsterFactory {
  113. public:
  114.     Monster* createMonster() override
  115.     {
  116.         return new T(300, 50, 80); // 如果需要不同的值则可以通过createMonster的形参将值传递进来
  117.     }
  118. };
  120. void FactorMode()
  121. {
  122.     {
  123.         // 产生亡灵类怪物
  124.         MonsterFactory* undeadFactor = new UndeadFactor();
  125.         Monster* undead = globalCreateMonster(undeadFactor);
  126.         // 产生元素类怪物
  127.         MonsterFactory* elementFactor = new ElementFactor();
  128.         Monster* element = globalCreateMonster(elementFactor);
  129.         // 产生机械类怪物
  130.         MonsterFactory* mechanicFactor = new MechanicFactor();
  131.         Monster* mechanic = globalCreateMonster(mechanicFactor);
  133.         delete undeadFactor;
  134.         delete undead;
  135.         delete elementFactor;
  136.         delete element;
  137.         delete mechanicFactor;
  138.         delete mechanic;
  139.     }
  140.     cout << endl;
  141.     {   // 封装怪物子类
  142.         ChildFactory<Undead> undeadFactory;
  143.         Monster* undead = undeadFactory.createMonster();
  144.         delete undead;
  145.     }
  146. }

定义：定义一个用于创建对象的接口，但由子类决定要实例化的类是哪一个。

  • 接口，即 MonsterFactory类中的createMonster()成员函数，这其实就是个工厂方法，工厂方法模式的名字也是由此而来。
  • 子类，即子工厂类 UndeadFactory、MechanicFactory、ElementFactory决定要实例化的类是哪一个。
  • 该模式使得某个类Undead、Mechanic、Element的实例化延迟到子类。

一般可以认为，将简单工厂模式的代码经过把工厂类进行抽象改造成符合开闭原则后的代码，就变成了工厂方法模式的代码。

把用 new创建对象集中到某个或者某些工厂类的成员函数中去做的好处是：

  • 封装变化：
  • 创建对象前需要一些额外的业务代码，可以将这些代码增加到具体的工厂类的createMonster()函数中。

简单工厂模式把创建对象这件事放到了一个统一的地方来处理，弹性比较差；而工厂方法模式相当于建立了一个程序实现框架，从而让子类来决定对象如何创建。
工厂方法模式往往需要创建一个与产品等级结构(层次)相同的工厂等级结构，这也增加了新类的层次结构和数目。

不想创建太多工厂类，又想封装变化，可以创建怪物工厂子类模板

  1. template <typename T>
  2. class ChildFactory : public MonsterFactory {
  3. public:
  4.     virtual Monster* createMonster()
  5.     {
  6.         return new T(300, 50, 80); // 如果需要不同的值则可以通过createMonster的形参将值传递进来
  7.     };
  8. };
  10. int main(int argc, char* argv[])
  11. {
  12.     ChildFactory<Undead> myFactory;
  13.     Monster* p10 = myFactory.createMonster();
  14.     delete p10;
  15. }

2.3 类图

6.工厂方法模式.svg

三、抽象工厂模式 Abstract Factory

3.1 战斗场景分类范例

3.1.1 功能策划

  • 怪物分类：亡灵类，元素类，机械类
  • （新增场景）战斗场景分类：沼泽地区，山脉地区，城镇。
  • 9类怪物：
    • 沼泽地区：亡灵类、元素类、机械类
    • 山脉地区：亡灵类、元素类、机械类
    • 城镇地区：亡灵类、元素类、机械类

工厂方法模式：一个工厂创建一种类怪物

但如果一个工厂子类能够创建不止一种而是多种具有相同规则的怪物对象，那么就可以有效的减少所创建的工厂子类数量，这就是抽象工厂模式的核心思想。

两个概念：

  • 产品等级结构
  • 产品族

抽象工厂模式是按照产品族来生产产品（产地相同的用一个工厂来生产）— 一个地点有一个工厂，该工厂负责生产本产地的所有产品。

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

3.1.2 示例代码

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

3.1.3 类图

7.抽象工厂模式.svg

3.1.4 优缺点

  • 增加森林类新场景，怪物种类不变。则只需要增加一个新子工厂比如FactoryForest，符合开闭原则。
  • 增加新怪物种类比如龙类，不但要增加三个继承自Monster的子类，还要针对ParentFactory增加新的虚函数接口比如createMonsterDragon，同时各个子工厂类都需要实现createMonsterDragon，这种修改代码的方式来增加新怪物种类，不符合开闭原则，所以增加新怪物的情形不适合抽象工厂模式。

  • 只增加一个产品族则符合开闭原则，只需要增加新工厂子类，这是该模式的优点。但若增加新产品等级结构，需要修改抽象层代码，这是抽象工厂模式的缺点。所以，应避免在产品等级结构不稳定的情况下使用该模式。也就是说，如果游戏中怪物种类（亡灵类，元素类，机械类）比较固定的情况下，更适合使用抽象工厂模式。

    3.2 不同厂商生产不同部件范例

    3.2.1 功能策划

  • 商品：芭比娃娃：身体（包括头、颈部、躯干、四肢）、衣服、鞋子

  • 厂商：中国，日本，美国

要求制作两个芭比娃娃：

  • 第一个：身体，衣服，鞋子，全部采用中国厂商制造的部件。
  • 第二个：身体采用中国厂商，衣服部件采用日本厂商，鞋子部件采用美国厂商。

image.png

3.2.2 示例代码

类的设计思路：

  • 将身体，衣服，鞋子 这三个部件实现为抽象类。
  • 实现一个抽象工厂，分别用来生产身体、衣服、鞋子这三个部件。
  • 针对不同厂商的每个部件实现具体的类以及每个厂商所代表的具体工厂。 ```cpp

    pragma once

    include

using namespace std;

// 身体抽象类 class Body { public: virtual void getName() = 0; virtual ~Body() {}; }; // 衣服抽象类 class Clothes { public: virtual void getName() = 0; virtual ~Clothes() {}; }; // 鞋子抽象类 class Shoes { public: virtual void getName() = 0; virtual ~Shoes() {}; };

// ———————————————————————————-

// 抽象工厂类 class AbstractFactory { public: // 所创建的部件应该稳定的保持这三个部件，才适合抽象工厂模式 virtual Body createBody() = 0; // 创建身体 virtual Clothes createClothes() = 0; // 创建衣服 virtual Shoes* createShoes() = 0; // 创建鞋子 virtual ~AbstractFactory() {}; };

// ———————————————————————————-

// 芭比娃娃类 class BarbieDoll { public: // 构造函数 BarbieDoll(Body body, Clothes clothes, Shoes* shoes) { m_body = body; m_clothes = clothes; m_shoes = shoes; } // 组装芭比娃娃 void assemble() { cout << “Successfully assembled the Barbie doll.” << endl; m_body->getName(); m_clothes->getName(); m_shoes->getName(); }

private: Body m_body; Clothes m_clothes; Shoes* m_shoes; };

// 中国厂商实现的三个部件及工厂 class ChinaBody : public Body { public: void getName() override { cout << “Body made in China” << endl; } }; class ChinaClothes : public Clothes { public: void getName() override { cout << “Clothes made in China” << endl; } }; class ChinaShoes : public Shoes { public: void getName() override { cout << “Shoes made in China” << endl; } }; class ChinaFactory : public AbstractFactory { Body createBody() override { // 创建身体 return new ChinaBody(); }; Clothes createClothes() override { // 创建衣服 return new ChinaClothes(); } Shoes* createShoes() override { // 创建鞋子 return new ChinaShoes(); } ~ChinaFactory() {}; };

// 日本厂商实现的三个部件及工厂 class JapanBody : public Body { public: void getName() override { cout << “Body made in Japan” << endl; } }; class JapanClothes : public Clothes { public: void getName() override { cout << “Clothes made in Japan” << endl; } }; class JapanShoes : public Shoes { public: void getName() override { cout << “Shoes made in Japan” << endl; } }; class JapanFactory : public AbstractFactory { Body createBody() override { // 创建身体 return new JapanBody(); }; Clothes createClothes() override { // 创建衣服 return new JapanClothes(); } Shoes* createShoes() override { // 创建鞋子 return new JapanShoes(); } ~JapanFactory() {}; };

// 美国厂商实现的三个部件及工厂 class AmericaBody : public Body { public: void getName() override { cout << “Body made in America” << endl; } }; class AmericaClothes : public Clothes { public: void getName() override { cout << “Clothes made in America” << endl; } }; class AmericaShoes : public Shoes { public: void getName() override { cout << “Shoes made in America” << endl; } }; class AmericaFactory : public AbstractFactory { Body createBody() override { // 创建身体 return new AmericaBody(); }; Clothes createClothes() override { // 创建衣服 return new AmericaClothes(); } Shoes* createShoes() override { // 创建鞋子 return new AmericaShoes(); } ~AmericaFactory() {}; };

void abstractFactorMode() { { // 第一个芭比娃娃: 身体,衣服,鞋子,全部采用中国厂商制造的部件 // 1.创建一个中国工厂 AbstractFactory chinaFactory = new ChinaFactory(); // 2. 创建中国生产的部件 Body body = chinaFactory->createBody(); Clothes clothes = chinaFactory->createClothes(); Shoes shoes = chinaFactory->createShoes(); // 3. 创建芭比娃娃 BarbieDoll* barbieDoll = new BarbieDoll(body, clothes, shoes); barbieDoll->assemble();

  1.     delete chinaFactory;
  2.     delete body;
  3.     delete clothes;
  4.     delete shoes;
  5.     delete barbieDoll;
  6. }
  8. cout << endl;
  10. { // 第二个芭比娃娃: 身体采用中国厂商,衣服部件采用日本厂商,鞋子部件采用美国厂商。
  11.     // 1.创建工厂
  12.     AbstractFactory* chinaFactory = new ChinaFactory();
  13.     AbstractFactory* japanFactory = new JapanFactory();
  14.     AbstractFactory* americaFactory = new AmericaFactory();
  15.     Body* body = chinaFactory->createBody();
  16.     Clothes* clothes = japanFactory->createClothes();
  17.     Shoes* shoes = americaFactory->createShoes();
  19.     BarbieDoll* barbieDoll = new BarbieDoll(body, clothes, shoes);
  20.     barbieDoll->assemble();
  22.     delete chinaFactory;
  23.     delete japanFactory;
  24.     delete americaFactory;
  25.     delete body;
  26.     delete clothes;
  27.     delete shoes;
  28.     delete barbieDoll;
  29. }

}

```

2.2.3 类图

抽象工厂方法模式2.svg

工厂方法模式和抽象工厂模式区别：

  • 工厂方法模式:一个工厂生产一个产品
  • 抽象工厂模式:一个工厂生产多个产品（产品族）

抽象工厂模式的定义（实现意图）：提供一个接口（AbstractFactory），
让该接口负责创建一系列相关或者相互依赖的对象(Body,Clothes,Shoes)，而无需指定他们具体的类。

三种工厂模式的总结：

  • 从代码实现复杂度：
  • 从需要的工厂数量上：
  • 从实际应用上：