一：概念
原型模式（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 <<
"\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;
}
模拟状态，我们不对原型对象进行修改
转载于:https://www.cnblogs.com/ssyfj/p/9537771.html
