(创建型模式)PROTOTYPE——原型模式

1、意图

原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

2、核心思想

     通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构。

3、优缺点分析

GOOD：

从一个对象再创建另外一个可定制的对象，而无需知道任何创建的细节。并能提高创建的性能。 说白了就COPY技术，把一个对象完整的COPY出一份。

一般在初始化的信息不发生变化的情况下，克隆是最好的办法。这既隐藏了对象创建的细节，又对性能是大大的提高。

BAD：

缺点是每一个类都必须配备一个复制方法。

必须注意：

浅复制和深复制的问题：如果字段是基本数据类型的，则用拷贝构造函数即可进行逐位复制，但如果字段是指针或引用类型的，则复制就不仅仅要复制指针和引用本身，还需要对其所指的实际数据对象进行复制。

4、标准UML图

抽象基类:

1）Prototype：虚拟基类，所有原型的基类，提供Clone接口函数

接口函数：

1）Prototype::Clone函数：纯虚函数，根据不同的派生类来实例化创建对象

解析：

原型模式实际就是常说的用虚函数模拟实现“虚拟构造函数”，C++的实现机制中并没有虚拟构造函数这个性质，但是通过不同派生类实现的Clone接口函数可以完成与“虚拟构造函数”同样的效果。

所以，生成一个新的对象，就是需要创建一个实际提供服务的对象，就需要一个已经存在的原型，和通过该原型对象创建实际服务对象的方法。

4、标准源码

   1: #ifndef PROTOTYPE_H

   2: #define PROTOTYPE_H

   3:  

   4: // 虚拟基类,所有原型的基类,提供Clone接口函数

   5: class Prototype

   6: {

   7: public:

   8:     Prototype(){}

   9:     virtual ~Prototype(){}

  10:  

  11:     virtual Prototype* Clone() = 0;

  12: };

  13:  

  14: // 派生自Prototype,实现Clone方法

  15: class ConcreatePrototype1

  16:     : public Prototype

  17: {

  18: public:

  19:     ConcreatePrototype1();

  20:     ConcreatePrototype1(const ConcreatePrototype1&);

  21:     virtual ~ConcreatePrototype1();

  22:  

  23:     virtual Prototype* Clone();

  24: };

  25:  

  26: // 派生自Prototype,实现Clone方法

  27: class ConcreatePrototype2

  28:     : public Prototype

  29: {

  30: public:

  31:     ConcreatePrototype2();

  32:     ConcreatePrototype2(const ConcreatePrototype2&);

  33:     virtual ~ConcreatePrototype2();

  34:  

  35:     virtual Prototype* Clone();

  36: };

  37:  

  38: #endif

   1: #include "Prototype.h"

   2: #include <iostream>

   3:  

   4: ConcreatePrototype1::ConcreatePrototype1()

   5: {

   6:     std::cout << "construction of ConcreatePrototype1\n";

   7: }

   8:  

   9: ConcreatePrototype1::~ConcreatePrototype1()

  10: {

  11:     std::cout << "destruction of ConcreatePrototype1\n";

  12: }

  13:  

  14: ConcreatePrototype1::ConcreatePrototype1(const ConcreatePrototype1&)

  15: {

  16:     std::cout << "copy construction of ConcreatePrototype1\n";

  17: }

  18:  

  19: Prototype* ConcreatePrototype1::Clone()

  20: {

  21:     return new ConcreatePrototype1(*this);

  22: }

  23:  

  24: ConcreatePrototype2::ConcreatePrototype2()

  25: {

  26:     std::cout << "construction of ConcreatePrototype2\n";

  27: }

  28:  

  29: ConcreatePrototype2::~ConcreatePrototype2()

  30: {

  31:     std::cout << "destruction of ConcreatePrototype2\n";

  32: }

  33:  

  34: ConcreatePrototype2::ConcreatePrototype2(const ConcreatePrototype2&)

  35: {

  36:     std::cout << "copy construction of ConcreatePrototype2\n";

  37: }

  38:  

  39: Prototype* ConcreatePrototype2::Clone()

  40: {

  41:     return new ConcreatePrototype2(*this);

  42: }