设计模式：创建型模式：原型模式（prototype pattern）

本文的内容是综合下面几篇文章，深表感谢：

1）http://www.cppblog.com/converse/archive/2006/07/21/10307.html

2）http://www.jellythink.com/archives/378

3）http://www.jellythink.com/archives/105

什么是原型模式：

原型模式就是你有一个对象，而且你可以复制拷贝出他的副本。这个被复制的对象就是所谓的原型。

有个特别好的配钥匙的例子：

Prototype模式其实就是常说的"虚拟构造函数"一个实现,C++的实现机制中并没有支持这个特性,但是通过不同派生类实现的Clone接口函数可以完成与"虚拟构造函数"同样的效果.举一个例子来解释这个模式的作用,假设有一家店铺是配钥匙的,他对外提供配制钥匙的服务(提供Clone接口函数),你需要配什么钥匙它不知道只是提供这种服务,具体需要配什么钥匙只有到了真正看到钥匙的原型才能配好.也就是说,需要一个提供这个服务的对象,同时还需要一个原型(Prototype),不然不知道该配什么样的钥匙.

原型模式的应用场景：

1. 当我们的对象类型不是开始就能确定的，而这个类型是在运行期确定的话，那么我们通过这个类型的对象克隆出一个新的对象比较容易一些；
2. 有的时候，我们需要一个对象在某个状态下的副本，此时，我们使用原型模式是最好的选择；例如：一个对象，经过一段处理之后，其内部的状态发生了变化；这个时候，我们需要一个这个状态的副本，如果直接new一个新的对象的话，但是它的状态是不对的，此时，可以使用原型模式，将原来的对象拷贝一个出来，这个对象就和之前的对象是完全一致的了；
3. 当我们处理一些比较简单的对象时，并且对象之间的区别很小，可能就几个属性不同而已，那么就可以使用原型模式来完成，省去了创建对象时的麻烦了；
4. 有的时候，创建对象时，构造函数的参数很多，而自己又不完全的知道每个参数的意义，就可以使用原型模式来创建一个新的对象，不必去理会创建的过程，让创建过程见鬼去吧。

UML

有个很有意思的问题是，使用原型模式和直接用拷贝构造函数（copy constructor）相比有什么区别？尤其是原型模式的clone()其实就是用子类的拷贝构造函数实现的。

我个人觉得，答案就在上面写的应用场景1里，如果直接用拷贝构造函数，我们是必须知道类型的；但是用原型模式，我们可以靠多态实现。

关于拷贝构造函数和重载赋值操作符（operator =），也是个很有意思的话题，见http://www.jellythink.com/archives/378

总的来说就是“如果对象在声明的同时将另一个已存在的对象赋给它，就会调用复制构造函数；如果对象已经存在了，然后再将另一个已存在的对象赋给它，调用的就是重载赋值运算符了”

关于实现原型模式，和对比直接用拷贝构造函数，具体看代码（代码改动自http://www.cppblog.com/converse/archive/2006/07/21/10307.html）

/********************************************************************

    created:    2006/07/20

    filename:     Prototype.cpp

    author:        李创

                http://www.cppblog.com/converse/

    purpose:    Prototype模式的演示代码

*********************************************************************/

#include "Prototype.h"

#include <stdlib.h>

int main()

{

    Prototype* pPrototype1 = new ConcreatePrototype1();

    pPrototype1->show(); // this is class ConcreatePrototype1

    Prototype* pPrototype2 = pPrototype1->Clone();

    pPrototype2->show(); // this is class ConcreatePrototype1

    Prototype* pPrototype3 = new ConcreatePrototype2();

    pPrototype3->show(); // this is class ConcreatePrototype2

    Prototype* pPrototype4 = pPrototype3->Clone();

    pPrototype4->show(); // this is class ConcreatePrototype2

    //ConcreatePrototype2 Prototype5(*pPrototype4);

    // 用copy constructor 必须要知道class

    // 用clone就无所谓了

    ConcreatePrototype2* pPrototype5 = new ConcreatePrototype2();

    pPrototype5->show();

    ConcreatePrototype2 Prototype6(*pPrototype5);

    Prototype6.show();

    delete pPrototype1;

    delete pPrototype2;

    delete pPrototype3;

    delete pPrototype4;

    delete pPrototype5;

    system("pause");

    return 0;

}

#ifndef PROTOTYPE_H

#define PROTOTYPE_H

// 虚拟基类,所有原型的基类,提供Clone接口函数

class Prototype

{

public:

    Prototype(){}

    virtual ~Prototype(){}

    virtual void show();

    virtual Prototype* Clone()=0;

};

// 派生自Prototype,实现Clone方法

class ConcreatePrototype1 : public Prototype

{

public:

    ConcreatePrototype1();

    ConcreatePrototype1(const ConcreatePrototype1&);

    virtual ~ConcreatePrototype1();

    virtual void show();

    virtual Prototype* Clone();

};

// 派生自Prototype,实现Clone方法

class ConcreatePrototype2 : public Prototype

{

public:

    ConcreatePrototype2();

    ConcreatePrototype2(const ConcreatePrototype2&);

    virtual ~ConcreatePrototype2();

    virtual void show();

    virtual Prototype* Clone();

};

#endif // PROTOTYPE_H

#include "Prototype.h"

#include <iostream>

void Prototype::show()

{

    std::cout << "this class prototype\n" ;

}

void ConcreatePrototype1::show()

{

    std::cout << "this class ConcreatePrototype1\n" ;

}

void ConcreatePrototype2::show()

{

    std::cout << "this class ConcreatePrototype2\n" ;

}

ConcreatePrototype1::ConcreatePrototype1()

{

    std::cout << "construction of ConcreatePrototype1\n";

}

ConcreatePrototype1::~ConcreatePrototype1()

{

    std::cout << "destruction of ConcreatePrototype1\n";

}

ConcreatePrototype1::ConcreatePrototype1(const ConcreatePrototype1&)

{

    std::cout << "copy construction of ConcreatePrototype1\n";

}

Prototype* ConcreatePrototype1::Clone()

{

    return new ConcreatePrototype1(*this);

}

ConcreatePrototype2::ConcreatePrototype2()

{

    std::cout << "construction of ConcreatePrototype2\n";

}

ConcreatePrototype2::~ConcreatePrototype2()

{

    std::cout << "destruction of ConcreatePrototype2\n";

}

ConcreatePrototype2::ConcreatePrototype2(const ConcreatePrototype2&)

{

    std::cout << "copy construction of ConcreatePrototype2\n";

}

Prototype* ConcreatePrototype2::Clone()

{

    return new ConcreatePrototype2(*this);

}

感悟：

就是多态版本的拷贝构造函数，由父类提供接口，对象自己决定调用哪个子类的拷贝构造函数。