设计模式---对象创建模式之原型模式（prototype）

一：概念

原型模式（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 BinarySplitter : public ISplitter{
    
};

class TxtSplitter: public ISplitter{
    
};

class PictureSplitter: public ISplitter{
    
};

class VideoSplitter: public ISplitter{
    
};

//具体工厂
class BinarySplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new BinarySplitter();
    }
};

class TxtSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new TxtSplitter();
    }
};

class PictureSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new PictureSplitter();
    }
};

class VideoSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new VideoSplitter();
    }
};

（二）原型模式处理：将两个类合并

1.将抽象类和抽象工厂合并

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

};

2.将具体类和具体工厂合并

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);
    }
};

（三）MainForm中使用

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

五：类图（结构）

六：使用场景：和工厂相比

（一）当某一个对象比较复杂的时候，通常你发现他的初始状态不是最理想的，这时候有一个对象，他的状态已经达到比较好的状态的时候，我们调用一下拷贝构造函数（深克隆），将他的状态取出来，这样就达到了一个比较好的状态。

（二）而我们使用工厂模式，我们创建一个新的对象，当对象结构复杂，我们new一个新的对象后，往往需要大量的操作去达到一个较好的状态，不够灵活，所以工厂模式适用于结构不太复杂的对象。

（三）二者区别在于是否有较复杂的中间状态，而且是否希望保留某个状态

（四）一个复杂对象，具有自我复制功能，统一一套接口

七：要点总结

（一）Prototype模式同样用于隔离类对象的使用者和具体类型（易变类）直接的耦合关系，他同样要求这些“易变类”拥有“稳定的接口”。

（二）Prototype模式对于“如何创建易变类的实体对象”采用“原型克隆”的方法来做，它使得我们可以非常灵活地“动态创建”拥有某些稳定接口的新对象——所需工作仅仅是注册一个新类的对象（即原型），然后在任何需要的地方clone。

（三）Prototype模式中的Clone方法可以利用某些框架中的序列化来实现深拷贝。

像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 << "	" << 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;
}

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