设计模式：原型模式(Prototype Pattern)通过复制生成实例

如果对象的创建成本比较大，而同一个类的不同对象之间差别不大（大部分字段都相同），在这种情况下，我们可以利用已有对象（原型）进行复制（或者叫做拷贝）的方式来创建新对象，已达到节省创建时间的目的。这种基于原型来创建对象的方式就叫作原型设计模式（Prototype Design Pattern），简称原型模式。

原型模式是用于创建重复的新对象，同时又能保证性能。这种类型的设计属于创建者模式，它提供了一种创建对象的最佳方式。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。

那何为“对象的创建成本比较大”

• 实际上，创建对象包含的申请内存、给成员变量赋值这一过程，本身并不会花费太多时间，或者说对于大部分业务系统来说，这点时间完全是可以忽略的。应用一个复杂的模式，只得到一点点的性能提升，这既是所谓的过度设计，得不偿失。
• 但是，如果对象中的数据需要经过复杂的计算才能得到（比如排序、计算哈希值），或者需要从RPC、网络、数据库、文件系统等非常慢速的IO中读取，这种情况下，我们就可以利用原型模式，从其他已有对象中直接拷贝得到，而不用每次在创建新对象的时候，都重复执行这些耗时的操作。

说明

• 意图：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象
• 使用场景：
  • 资源优化场景
  • 类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等
  • 通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式
  • 在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者

实现方式：深拷贝和浅拷贝

原型模式有两种实现方法，深拷贝和浅拷贝。

• 浅拷贝只会复制对象中基本数据类型数据和引用对象的内存地址，不会递归地复制引用对象，以及引用对象的引用对象……
• 而深拷贝得到的是一份完完全全独立的对象。所以，深拷贝比起浅拷贝来说，更加耗时，更加耗内存空间。

那如何实现深拷贝呢？总结一下的话，有下面两种方法。

• 第一种方法：递归拷贝对象、对象的引用对象以及引用对象的引用对象…直到要拷贝的对象只包含基本数据类型数据，没有引用对象为止。
• 第二种方法：先将对象序列化，然后再反序列化成新的对象。具体的示例代码如下所示：

public Object deepCopy(Object object) {
	ByteArrayOutputStream bo = new ByteArrayOutputStream();
	ObjectOutputStream oo = new ObjectOutputStream(bo);
	oo.writeObject(object);
	ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
	ObjectInputStream oi = new ObjectInputStream(bi);
	return oi.readObject();
}

注意：

• 如果要拷贝的对象是不可变对象，浅拷贝共享不可变对象是没问题的
• 但对于可变对象来说，浅拷贝得到的对象和原始对象会共享部分数据，就有可能出现数据被修改的风险，也就变得复杂多了。
• 除非类似需要从数据库中加载 10 万条数据并构建散列表索引，操作非常耗时，比较推荐使用浅拷贝，否则，没有充分的理由，不要为了一点点的性能提升而使用浅拷贝。

实现

实现

#include <iostream>
#include <string>
#include <memory>
using namespace std;
class Person
{
public:
    string name;
    int age;
    Person(string _name, int _age) :name(_name), age(_age) {}
    virtual ~Person() {}
    virtual void showMe()
    {
        cout << "I am " << name << ", and " << age << endl;
    }
    virtual Person *clone()
    {
        return new Person(*this);
    }
};

class Boy :public Person
{
public:
    Boy(string _name, int _age):Person(_name, _age)
    {}
    ~Boy() {}
    virtual void showMe() override
    {
        Person::showMe();
        cout << "I am a boy" << endl;
    }
    virtual Person *clone() override
    {
        return new Boy(*this);
    }
};
class Girl :public Person
{
public:
    Girl(string _name, int _age) :Person(_name, _age)
    {}
    ~Girl() {}
    virtual void showMe() override
    {
        Person::showMe();
        cout << "I am a Girl" << endl;
    }
    virtual Person *clone() override
    {
        return new Girl(*this);
    }
};

int main()
{
    //创建一个boy  a
    Person *a = new Boy(string("Ming"), 28);
    a->showMe();
    //创建一个Girl  b
    Person *b = new Girl(string("Li"), 28);
    b->showMe();

    //克隆a--不使用原型模式的写法
    shared_ptr<Person> cloneA(new Boy(*dynamic_cast<Boy *>(a)));
    cloneA->showMe();

    //克隆b--使用原型模式的写法
    shared_ptr<Person> cloneB(b->clone());
    cloneB->showMe();

    delete b;
    delete a;

    return 0;
}

实现

登场角色：

• Prototype（原型）：
  • 负责定义复制现有实例来生成新实例的方法
• ConcretePrototype（具体的原型）：
  • ConcretePrototype负责实现复制现有原型并生成新实例的方法

• Client（使用者）：
  • 负责使用复制实例生成新得实例。

#include <iostream>
using namespace std;


class Prototype{
public:
    virtual Prototype *Clone() = 0;
    virtual ~Prototype(){};
};

class ConcretePrototype : public Prototype{
public:
    ConcretePrototype(){}

    ConcretePrototype(const ConcretePrototype&cp) {
        cout << "ConcretePrototype copy..." << endl;
    }

    Prototype* Clone() {
        return new ConcretePrototype(*this);
    }
};

int main(void){
    Prototype *prototype = new ConcretePrototype();
    cout << prototype << endl;
    Prototype* prototype1 = prototype->Clone();
    cout << prototype1 << endl;
    Prototype* prototype2 = prototype->Clone();
    cout << prototype2 << endl;

    delete prototype;
    delete prototype1;
    delete prototype2;

    return 0;
}

原型模式的结构和实现都很简单，其关键就是（C++中）拷贝构造函数的实现方式，这也是 C++实现技术层面上的事情。由于在示例代码中不涉及到深层拷贝（主要指有指针、复合对象的情况），因此我们通过编译器提供的默认的拷贝构造函数（按位拷贝）的方式进行实现。说明的是这一切只是为了实现简单起见，也因为本文档的重点不在拷贝构造函数的实现技术，而在原型模式本身的思想。

C++原型模式
c++设计模式（原型模式）