设计模式--创建型-Prototype（原形）

 

设计模式--创建型-Prototype（原形）

 

 

 

1.意图

 

用原形实例指定创建对象的种类，并且通过拷贝这些原形创建新的对象。

 

 

 

2. 结构图

 

 

 

 

3. 简述

 

在一个特定的场景中经常需要出现多个相同但状态（种类）各异的对象，通常的解决方法是使用原形模式，从已有的对象拷贝出新的对象，这样可以减少客户知道的类的名字数目。

对Client程序来说，原型和抽象工厂的类似，只是内部的CreateProductA等不是每次都简单的new一个实例，而是用已有的原形实例去克隆一个新实例。

 

 

 

4.实例代码

 

4.1 对外的接口的定义，给客户Client使用

class PrototypeA

{

     int  _type;

 

public:

     PrototypeA() {}

     PrototypeA( const PrototypeA& other){ /*深拷贝*/ }

     virtual ~PrototypeA(){}

 

     virtual PrototypeA*Clone() { returnnew PrototypeA(*this); }

     virtual void Init( int nType ) { _type= nType; }

     virtual void FunA() {}

};

 

class PrototypeB

{

public:

     PrototypeB() {}

     PrototypeB( const PrototypeB& other){ /*深拷贝*/ }

     virtual ~PrototypeB(){}

 

     virtual PrototypeB*Clone() { returnnew PrototypeB(*this); }

     virtual void FunB() {}

};

 

class PrototypeFactory

{

     PrototypeA*   _prototypeA;

     PrototypeB*   _prototypeB;

 

public:

     PrototypeFactory( PrototypeA*pA, PrototypeB*pB )

         : _prototypeA(pA),

         _prototypeB(pB){}

 

     PrototypeA* CreatePrototypeA_Type1()

     {

         PrototypeA* pA= _prototypeA->Clone();

         pA->Init(1);

         return pA;

     }

 

     PrototypeA* CreatePrototypeA_Type2()

     {

         PrototypeA* pA= _prototypeA->Clone();

         pA->Init(2);

         return pA;

     }

 

     PrototypeB* CreatePrototypeB()

     {

         return _prototypeB->Clone();

     }

};

 

 

 

4.3 客户Client程序

 

可以对原形进行集成扩展：

 

class ConcretePrototypeB : public PrototypeB

{

public:

     ConcretePrototypeB() {}

     ConcretePrototypeB( constConcretePrototypeB& other ){ /*深拷贝*/ }

     ~ConcretePrototypeB() {}

 

     PrototypeB* Clone(){ return new ConcretePrototypeB(*this);}

     void FunB() {}

};

 

 

int main()

{

     PrototypeFactory factory(new PrototypeA,new ConcretePrototypeB);

     PrototypeA* pProA1= factory.CreatePrototypeA_Type1();

     pProA1->FunA();

 

     PrototypeA* pProA2= factory.CreatePrototypeA_Type2();

     pProA2->FunA();

 

     PrototypeB* pProB= factory.CreatePrototypeB();

     pProB->FunB();

 

     delete pProA1;

     delete pProA2;

     delete pProB;

}