原型模式：通过一个对象（原型对象）克隆出多个一模一样的对象。

  • 克隆对象自身实际上是需要调用类的拷贝构造函数。
  • 克隆对象意味着复制出一个全新的对象，所以设计到深浅拷贝时都要实现深拷贝

    一、通过工厂方法模式演变到原型模式

    ```cpp

    pragma once

/ 原型模式:通过一个对象(原型模式)克隆出多个一模一样的对象 通过工厂模式演变成原型模式 /

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() { }

  1. // 具体的实现在子类中进行
  2. virtual Monster* clone() = 0;

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; } // 拷贝构造函数 Undead(const Undead& el) : Monster(el) { // 初始化类别中注意对父类子对象的初始化 cout << “Calling the copy constructor creates an undead class monster.” << endl; } Monster clone() override { //return new Undead(300, 80, 80); // 创建亡灵类怪物 return new Undead(this); // 触发拷贝构造函数的调用来创建亡灵类怪物 } // …其他代码略 };

// 元素类怪物 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(const Element& el) : Monster(el) { // 初始化类别中注意对父类子对象的初始化 cout << “Calling the copy constructor creates an element class monster.” << endl; } Monster clone() override { return new Element(this); } // …其他代码略 };

// 机械类怪物 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(const Mechanic& el) : Monster(el) { // 初始化类别中注意对父类子对象的初始化 cout << “Calling the copy constructor creates an mechanic class monster.” << endl; } Monster clone() override { return new Mechanic(this); } // …其他代码略 };

void protytype1() { // 创建一只机械类怪物对象作为原型对象以用于克隆目的 Mechanic mechanic(400, 0, 110); // 创建一只元素类怪物对象作为原型对象以用于克隆目的 Monster* element = new Element(200, 80, 100); // 可以直接new,也可以通过工厂模式来创建原型对象

  1. Monster* clone1 = mechanic.clone(); // 使用原型对象克隆出新的机械类怪物对象
  2. Monster* clone2 = element->clone(); // 使用原型对象克隆出新的元素类怪物对象
  4. // 可以对clone1 clone2所指向的对象进行各种操作(实现具体的业务逻辑)
  5. // ...
  6. // 释放资源(克隆出来的怪物对象、堆中创建的对象)
  7. delete clone1;
  8. delete clone2;
  9. delete element;

}

  1. <a name="arf9w"></a>
  2. # 二、引入原型模式
  3. <a name="zdCDN"></a>
  4. ## 2.1 定义
  5. 定义：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。简单来说就是通过克隆来创建新的对象实例。
  6. <a name="GeWCR"></a>
  7. ## 2.2 示例代码
  8. ```cpp
  9. #pragma once
  11. #include <iostream>
  13. using namespace std;
  15. class Monster {
  16. public:
  17.     // 构造函数
  18.     Monster(int life, int magic, int attack)
  19.         : m_life(life)
  20.         , m_magic(magic)
  21.         , m_attack(attack)
  22.     {
  23.     }
  24.     // 做父类时析构函数应该为虚函数
  25.     virtual ~Monster() { }
  27.     // 具体的实现在子类中进行
  28.     virtual Monster* clone() = 0;
  30. protected:
  31.     int m_life; // 生命值
  32.     int m_magic; // 魔法值
  33.     int m_attack; // 攻击力
  34. };
  36. // 亡灵类怪物
  37. class Undead : public Monster {
  38. public:
  39.     // 构造函数
  40.     Undead(int life, int magic, int attack)
  41.         : Monster(life, magic, attack)
  42.     {
  43.         cout << "A undead monster came into the world." << endl;
  44.     }
  45.     // 拷贝构造函数
  46.     Undead(const Undead& el)
  47.         : Monster(el)
  48.     { // 初始化类别中注意对父类子对象的初始化
  49.         cout << "Calling the copy constructor creates an undead class monster." << endl;
  50.     }
  51.     Monster* clone() override
  52.     {
  53.         //return new Undead(300, 80, 80);  // 创建亡灵类怪物
  54.         return new Undead(*this); // 触发拷贝构造函数的调用来创建亡灵类怪物
  55.     }
  56.     // ...其他代码略
  57. };
  59. // 元素类怪物
  60. class Element : public Monster {
  61. public:
  62.     // 构造函数
  63.     Element(int life, int magic, int attack)
  64.         : Monster(life, magic, attack)
  65.     {
  66.         cout << "A element monster came into the world." << endl;
  67.     }
  68.     // 拷贝构造函数
  69.     Element(const Element& el)
  70.         : Monster(el)
  71.     { // 初始化类别中注意对父类子对象的初始化
  72.         cout << "Calling the copy constructor creates an element class monster." << endl;
  73.     }
  74.     Monster* clone() override
  75.     {
  76.         return new Element(*this);
  77.     }
  78.     // ...其他代码略
  79. };
  81. // 机械类怪物
  82. class Mechanic : public Monster {
  83. public:
  84.     // 构造函数
  85.     Mechanic(int life, int magic, int attack)
  86.         : Monster(life, magic, attack)
  87.     {
  88.         cout << "A mechanic monster came into the world." << endl;
  89.     }
  90.     // 拷贝构造函数
  91.     Mechanic(const Mechanic& el)
  92.         : Monster(el)
  93.     { // 初始化类别中注意对父类子对象的初始化
  94.         cout << "Calling the copy constructor creates an mechanic class monster." << endl;
  95.     }
  96.     Monster* clone() override
  97.     {
  98.         return new Mechanic(*this);
  99.     }
  100.     // ...其他代码略
  101. };
  103. // 没有克隆方法时需要类型转换进行判断来创建对象
  104. void globalCreateMonster(Monster* monster)
  105. {
  106.     Monster* tempMonster = nullptr;
  107.     if (dynamic_cast<Undead*>(monster) != nullptr) {
  108.         tempMonster = new Undead(300, 50, 80);
  109.     } else if (dynamic_cast<Element*>(monster) != nullptr) {
  110.         tempMonster = new Element(200, 80, 100);
  111.     } else if (dynamic_cast<Mechanic*>(monster) != nullptr) {
  112.         tempMonster = new Mechanic(200, 80, 100);
  113.     }
  114.     if (tempMonster != nullptr) {
  115.         // 实现各种业务逻辑
  116.         // ....
  117.         // 不要忘记释放资源
  118.         delete tempMonster;
  119.     }
  120. }
  122. // 有克隆方法时
  123. void globalCreateMonster2(Monster* monster)
  124. {
  125.     // 根据已有对象直接创建新对象,不需要已有对象所属的类型
  126.     Monster* tempMonster = monster->clone();
  127.     // 实现各种业务逻辑
  128.     // ....
  129.     // 不要忘记释放资源
  130.     delete tempMonster;
  131. }
  133. void protytype2()
  134. {
  135.     // 创建一只元素类怪物
  136.     Monster* element = new Element(200, 80, 100);
  137.     globalCreateMonster2(element);
  138.     delete element;
  139. }

2.3 类图

原型模式.svg
由类图可看出，原型模式的两种角色：

  • Prototype（抽象原型类）：Monster类
  • ConcretePrototype（具体原型类）：Undead、Element、Mechanic类

如果对象内部数据比较复杂多变并且在创建对象的时候希望保持对象的当前状态，那么用原型模式显然比用工厂方法模式更合适。

2.4 工厂模式与原型模式的异同点

  • 都不需要程序员知道所创建对象所属的类名。
  • 工厂方法模式中的createMonster仍旧属于根据类名来生成新对象。
  • 原型模式中的clone是根据现有对象来生成新对象。
  • 可以把原型模式看成是一种特殊的工厂方法模式。

2.5 原型模式优缺点

  • 如果创建的新对象内部数据比较复杂且多变，原型模式创建对象的效率可能会高很多。
  • 原型模式不存在额外的等级结构——原型模式不需要额外的工厂类。
  • clone接口的实现方法有多种。
  • 有些情况下，产品类中存在一个克隆方法也会给开发提供一些明显便利。