一、原型模式描述

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

Prototype原型模式是一种创建型设计模式，Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节。

工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

二、解决的问题

它主要面对的问题是：“某些结构复杂的对象”的创建工作；由于需求的变化，这些对象经常面临着剧烈的变化，但是他们却拥有比较稳定一致的接口。

三、组成

客户（Client）角色：客户端类向原型管理器提出创建对象的请求。

1. 抽象原型（Prototype）角色：这是一个抽象角色，通常由一个C#接口或抽象类实现。
2. 具体原型（Concrete Prototype）角色：被复制的对象。此角色需要实现抽象的原型角色所要求的接口。
3. 原型管理器（Prototype Manager）角色：创建具体原型类的对象，并记录每一个被创建的对象。

四、类图

五、C++代码实现

注意：这里不带有原型管理器

#include <iostream>
#include <cstring>



/// 原型抽象类 -=> 对应于抽象原型（Prototype）角色
class Prototype
{
public :
    Prototype( ){  };

    virtual ~Prototype( ){ };

    virtual Prototype* Clone( ) const = 0;  // 拷贝函数，原型模式的精髓所在

    virtual void Show( ) const = 0;                // 显示当前信息
protected :
    char *m_name;               // 名字
};





/// 原型类A -=> 对应于具体原型（Concrete Prototype）角色：
class PrototypeA : public Prototype
{
public :
    PrototypeA(const char *name = NULL)           // 构造函数
    {
        if(name == NULL)
        {
            this->m_name = new char[1];
            strcpy(this->m_name, "");
        }
        else
        {
            this->m_name = new char[strlen(name) + 1];
            strcpy(this->m_name, name);
        }
    }

    PrototypeA(const PrototypeA &Prototype)               // 实现深拷贝
    {
        this->m_name = new char[strlen(Prototype.m_name)];
        strcpy(this->m_name, Prototype.m_name);
    }

    virtual ~PrototypeA( )                 // 虚析构函数
    {
        delete[] this->m_name;
    }

    Prototype* Clone( ) const  // 拷贝函数，原型模式的精髓所在
    {
        return new PrototypeA(*this);
    }

    void Show( ) const                // 显示当前函数信息
    {
        std::cout <<"PrototypeA's name is " <<this->m_name <<std::endl;
    }
//protected :
//  char *m_name;
};


/// 原型类B -=> 对应于具体原型（Concrete Prototype）角色：
class PrototypeB : public Prototype
{
public :
    PrototypeB(const char *name = NULL)          // 构造函数
    {
    if(name == NULL)
    {
        this->m_name = new char[1];
        strcpy(this->m_name, "");
    }
    else
    {
        this->m_name = new char[strlen(name) + 1];
        strcpy(this->m_name, name);
    }
    }
    PrototypeB(const PrototypeB &Prototype)               //
    {
        this->m_name = new char[strlen(Prototype.m_name)];
        strcpy(this->m_name, Prototype.m_name);
    }

    virtual ~PrototypeB( )                // 虚析构函数
    {
        delete[] this->m_name;
    }
    Prototype* Clone( ) const  // 拷贝函数，原型模式的精髓所在
    {
        return new PrototypeB(*this);
    }                      // 获取名字的函数
    void Show( ) const                // 显示当前函数信息
    {
        std::cout <<"PrototypeB's name is " <<this->m_name <<std::endl;
    }
//protected :
//  int     *m_no;
};




int main()
{
    Prototype *r1 = new PrototypeA("A");
    Prototype *r2 = r1->Clone( );

    // r1和r2是相同内容的副本
    r1->Show( );
    r2->Show( );
    delete r1;
    delete r2;
    r1 = r2 = NULL;

    Prototype *r3 = new PrototypeB("B");
    Prototype *r4 = r3->Clone( );
    // r1和r2是用相同内容的拷贝
    r3->Show( );
    r4->Show( );
    delete r3;
    delete r4;
    r3 = r4 = NULL;

    return 0;
}

六、总结

模式优点

1. 如果创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率。
2. 可以使用深克隆保持对象的状态。
3. 原型模式提供了简化的创建结构。

模式缺点

1. 在实现深克隆的时候可能需要比较复杂的代码。
2. 需要为每一个类配备一个克隆方法，而且这个克隆方法需要对类的功能进行通盘考虑，这对全新的类来说不是很难，但对已有的类进行改造时，不一定是件容易的事，必须修改其源代码，违背了“开闭原则”。

使用场景

1. 如果创建新对象成本较大，我们可以利用已有的对象进行复制来获得。
2. 如果系统要保存对象的状态，而对象的状态变化很小，或者对象本身占内存不大的时候，也可以使用原型模式配合备忘录模式来应用。相反，如果对象的状态变化很大，或者对象占用的内存很大，那么采用状态模式会比原型模式更好。
3. 需要避免使用分层次的工厂类来创建分层次的对象，并且类的实例对象只有一个或很少的几个组合状态，通过复制原型对象得到新实例可能比使用构造函数创建一个新实例更加方便。

原型模式向客户隐藏了创建对象的复杂性。客户只需要知道要创建对象的类型，然后通过请求就可以获得和该对象一模一样的新对象，无须知道具体的创建过程。

克隆分为浅克隆和深克隆两种。

我们虽然可以利用原型模式来获得一个新对象，但有时对象的复制可能会相当的复杂，比如深克隆。

---

参考：
https://blog.csdn.net/gatieme/article/details/17960555
https://www.cnblogs.com/chenssy/p/3313339.html