设计模式---对象创建模式之原型模式(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 << "\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;
}

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

 

 

 

posted @ 2018-08-26 16:59  山上有风景  阅读(324)  评论(0编辑  收藏  举报