原型模式

一 应用场景
填写一个报表，有些重复的内容不必每次都偶重复填写，只需保存一个固定的模板，只需要填写不重复的内容即可。

一 定义
使用原型实例指定创建对象的种类，并且通过克隆这些原型创建新的对象，它是一种对象创建型模式。
将一个原型对象传递给要发动创建的对象，这个要发动创建的对象通过请求原对象克隆自己来实现创建过程。本质用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

Prototype 抽象原型类，申明克隆方法的接口是所有具体原型类的公共父类。
Concrete Prototype 具体原型类，在克隆方法中返回自己的一个克隆对象，也就是被复制的对象。
Client 客户类，让一个原型对象克隆自身从而创建一个新的对象。

C++实现的原型模式如下
ProtoType.h

#include <stdio.h>


class ProtoType
{
protected:
    char type;
    int value;

public:
    ProtoType();
    virtual ~ProtoType();
    virtual ProtoType * clone() = 0;
    char getType();
    int getValue();
};


class ConProType1:public ProtoType
{
public:
    ConProType1(int num);
    virtual ~ConProType1();
    ProtoType * clone();
};


class ConProType2:public ProtoType
{
public:
    ConProType2(int num);
    virtual ~ConProType2();
    ProtoType * clone();
};

ProtoType.cpp

#include "ProtoType.h"


ProtoType::ProtoType(){}


ProtoType::~ProtoType(){}


char ProtoType::getType()
{
    return type;
}


int ProtoType::getValue()
{
    return value;
}


ConProType1::ConProType1(int num)
{
    type = 'A';
    value = num;
}


ConProType1::~ConProType1(){}


ProtoType * ConProType1::clone()
{
    return new ConProType1(*this);
}


ConProType2::ConProType2(int num)
{
    type = 'B';
    value = num;
}


ConProType2::~ConProType2(){}


ProtoType * ConProType2::clone()
{
    return new ConProType2(*this);
}

client.cpp

int main()
{
    ProtoType * p1 = new ConProType1(1);
    ProtoType * p2 = new ConProType2(2);
    ProtoType * p3 = p1->clone();
    ProtoType * p4 = p2->clone();
    printf("p1:%d\n",p1->getValue());
    printf("p2:%d\n",p2->getValue());
    printf("p3:%d\n",p3->getValue());
    printf("p4:%d\n",p4->getValue());

    system("pause");
}

运行结果：

优点：
1 创建新的对象较为复杂的时候，使用原型模式可以简化对象的创建过程。

缺点：
1 每个类都要配置一个克隆方法。