原型模式（Prototype Pattern）  实际上就是动态抽取当前对象运行时的状态

Prototype模式是一种对象创建型模式，它采取复制原型对象的方法来创建对象的实例。使用Prototype模式创建的实例，具有与原型一样的数据。

1）由原型对象自身创建目标对象。也就是说，对象创建这一动作发自原型对象本身。

2）目标对象是原型对象的一个克隆。也就是说，通过Prototype模式创建的对象，不仅仅与原型对象具有相同的结构，还与原型对象具有相同的值。

3）根据对象克隆深度层次的不同，有浅度克隆与深度克隆。

适用情况： 一个复杂对象，具有自我复制功能，统一一套接口。 对于对象比较复杂，每创建一次new 都会浪费好多的资源和时间 且在初始化的信息不发生变化的前提下 克隆是最好的办法，

在软件系统中，经常面临着“某些结构复杂的对象”的创建工作；由于需求的变化，这些对象经常面临着剧烈的变化，但是他们却拥有着比较稳定一致的接口。

如何应对这种变化？如何向“客户程序（使用这些对象的程序）”隔离出“这些易变对象”，从而使得“依赖这些易变对象的客户程序”不随着需求改变而改变？

原型模式也是属于对象创建模式，它用来处理某些结构复杂对象的创建工作，这也是与工厂模式最大的区别。

如果我们要创建的对象比较简单的话，使用工厂模式new一下就可以了，但是当对象比较复杂，它的初始状态不是我们最想用的时候，我们可以调用拷贝构造函数来深拷贝某个比较符合我们要求的对象。当然所谓的复杂是相对而言的，应当根据实际情况确定。

//抽象类
class ISplitter{
public:
    virtual void split()=0;
    virtual ~ISplitter(){}
};


//工厂基类
class SplitterFactory{
public:
    virtual ISplitter* CreateSplitter()=0;
    virtual ~SplitterFactory(){}
};

//抽象类
class ISplitter{
public:
    virtual void split()=0;
    //通过克隆自己来创建对象
    virtual ISplitter* clone()=0;    //CreateSplitter
    
    virtual ~ISplitter(){}

};

class BinarySplitter : public ISplitter{　　//由原来的具体类和具体工厂合并
public:
    virtual ISplitter* clone(){
        return new BinarySplitter(*this);　　//深拷贝，将原有状态一并拷贝过去
    }
};

class TxtSplitter: public ISplitter{
public:
    virtual ISplitter* clone(){
        return new TxtSplitter(*this);
    }
};

class PictureSplitter: public ISplitter{
public:
    virtual ISplitter* clone(){
        return new PictureSplitter(*this);
    }
};

class VideoSplitter: public ISplitter{
public:
    virtual ISplitter* clone(){
        return new VideoSplitter(*this);
    }
};

class MainForm : public Form
{
    Isplitter*  prototype;//原型对象

public:
    
    MainForm(Isplitter*  prototype){
        this->prototype=prototype;
    }
    
    void Button1_Click(){
        //prototype->split;    不能直接使用，原型对象是专门供你克隆的，真正使用的时候，我们要使用新的对象
        
        ISplitter * splitter=
            prototype->clone(); //克隆原型
        
        splitter->split();
    }
};

使用原型实例指定创建对象的种类，然后通过拷贝这些原型来创建新的对象。 

                                                               --《设计模式》Gof

像python中pickle

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <stdlib.h>
#include <string>　　//需要加上string，不然cout<<string对象会报错
using namespace std;


class Programmer
{
public:
    virtual Programmer* clone() = 0;　　//接口
    virtual void printInfo() = 0;
    virtual void setJob(char *job) = 0;
    virtual ~Programmer(){}
};

class JavaProgrammer :public Programmer
{
private:
    string name;
    int age;
    char* job;
public:
    JavaProgrammer(string name, int age)
    {
        this->name = name;
        this->age = age;
        job = NULL;
    }

    virtual void setJob(char *job)
    {
        this->job = new char[strlen(job) + 1];
        strcpy(this->job, job);
    }

    virtual void printInfo()
    {
        cout << this->name << "\t" << this->age << endl;
        if (this->job)
            cout << this->job << endl;
    }

    virtual Programmer* clone()
    {
        Programmer* p = new JavaProgrammer(*this);　　//对其中指针，只是赋值，指向同一块空间
        p->setJob(this->job);　　//注意这一步，要做到深拷贝
        return p;
    }

    virtual ~JavaProgrammer()
    {
        if (this->job!=NULL)
        {
            delete[] this->job;
            this->job = NULL;
        }
    }
};

void main()
{
    JavaProgrammer jv1("Mark", 20);
    jv1.setJob("java programmer");
    jv1.printInfo();
    Programmer* np = jv1.clone();
    np->printInfo();

    delete np;　　//保错是因为拷贝问题

    system("pause");
    return;
}

模拟状态，我们不对原型对象进行修改