prototype 设计模式

概要 ： 使用一个原型实例来指定要创建的对象， 通过拷贝原型来创建一个新的实例

应用 ： 当一个系统独立于对象的创建，构造过程，和表示的时候

              1.当要实例化的类是在运行时指定的

              2.避免创建一个平行于产品类层次的工厂类层次

              3.当一个类的实例只有不同状态组合中一小部分， 通常安装特定数量的原型，通过拷贝而不是类的实例化通常较为方便

代码：

 

#include<iostream>
#include<vector>
using namespace std;

class Clonable
{
public:
    virtual Clonable* clone() = 0;

    virtual ~Clonable() {}

};

class Float : public Clonable
{
public:
    Float(float v) : _value(v)
    {

    }

    float getValue()
    {
        return _value;
    }

    Float* clone()
    {
        Float* pRet = new Float(_value);
        return pRet;
    }

    ~Float()
    {

    }

private:
    float _value;
};

class Double : public Clonable
{
public:
    Double(float v) : _value(v)
    {

    }

    double getValue()
    {
        return _value;
    }

    Double* clone()
    {
        Double* pRet = new Double(_value);
        return pRet;
    }

    ~Double()
    {

    }

private:
    double _value;
};

class Array : public Clonable
{
public:

virtual Array* clone()
{
    Array* ret = new Array();

    vector<Clonable*>::iterator it = data.begin();

    for(; it != data.end(); ++it)
    {
        Clonable* cloneObj = (*it)->clone();
        ret->addObject(cloneObj);
    }

    return ret;
}

void addObject(Clonable* object)
{
    data.push_back(object);
}

~Array()
{
    vector<Clonable*>::iterator it = data.begin();

    for(; it != data.end(); ++it)
    {
        Clonable* cloneObj = (*it)->clone();
        delete cloneObj;
    }

}

private:

vector<Clonable*> data;
};

int main(int argc, char** argv)
{

    Float f1(1.0f);
    Float f2(2.0f);

    Double d1(3.0);
    Double d2(4.0);

    Array array1;
    array1.addObject(&f1);
    array1.addObject(&f2);
    array1.addObject(&d1);
    array1.addObject(&d2);

    Array* array2 = array1.clone();

    if(array2 != &array1)
    {
        cout << "copy successfully" << endl;
    }
    else
    {
        cout << "not success" << endl;
    }

}