Prototype-原型模式

动机

• 在软件系统中，经常面临着“ 某些结构复杂的对象 ”的创建工作；由于需求的变化，这些对象经常面临着剧烈的变化，但是它们却拥有比较稳定一致的接口
• 如何应对这种变化，如何向“客户程序（使用这些对象的程序）”隔离出“这些易变对象”，从而使得“依赖这些易变对象的客户程序”不随着需求改变而改变？

模式定义

使用原型实例指定创建对象的种类，然后通过拷贝这些原型来创建新的对象

结构

要点

• Prototype 模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些“易变类”拥有“稳定的接口”
• Prototype 模式对于“如何创建易变类的实体对象”采用“原型克隆”的方法来做，使得我们可以非常灵活地动态创建“拥有某些稳定接口”的新对象 — 所需工作仅仅是注册一个新类的对象（即原型），然后在任何需要的地方 clone
• Prototype 模式中的 clone 方法可以利用某些框架中的序列化来实现深拷贝

代码

#include <iostream>
#include <cstring>

using namespace std;

// 关键词:Clone, 深拷贝

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

class ConcretePrototypeA : public Prototype {
private:
    char* m_string;

public:
    ConcretePrototypeA(const char* data = 0)
    {
        if (data)
        {
            m_string = new char[strlen(data) + 1];
            strcpy(m_string, data);
        }
        else
        {
            m_string    = new char[1];
            m_string[0] = '\0';
        }
    }

    ConcretePrototypeA(ConcretePrototypeA& protoType)
    {
        m_string = new char[strlen(protoType.m_string) + 1];
        strcpy(m_string, protoType.m_string);
    }
    ~ConcretePrototypeA()
    {
        delete[] m_string;
    }
    virtual Prototype* Clone()
    {
        return new ConcretePrototypeA(*this);
    }
    void Tell()
    {
        cout << m_string << endl;
    }
};

class ConcretePrototypeB : public Prototype {
private:
    char* m_string;

public:
    ConcretePrototypeB(const char* data = 0)
    {
        if (data)
        {
            m_string = new char[strlen(data) + 1];
            strcpy(m_string, data);
        }
        else
        {
            m_string    = new char[1];
            m_string[0] = '\0';
        }
    }

    ConcretePrototypeB(ConcretePrototypeB& protoType)
    {
        m_string = new char[strlen(protoType.m_string) + 1];
        strcpy(m_string, protoType.m_string);
    }
    ~ConcretePrototypeB()
    {
        delete[] m_string;
    }
    virtual Prototype* Clone()
    {
        return new ConcretePrototypeB(*this);
    }
    void Tell()
    {
        cout << m_string << endl;
    }
};

enum PROTOTYPE_TYPE
{
    TYPEA   = 0,
    TYPEB   = 1,
    MAXTYPE = 2
} proType;

class ClientPrototype
{
private:
    static Prototype* m_prototype[MAXTYPE];

public:
    ~ClientPrototype()
    {
        for (unsigned int i = 0; i < MAXTYPE; i++)
        {
            if (m_prototype[i])
            {
                delete m_prototype[i];
            }
        }
    }
    static void Init()
    {
        if (!m_prototype[TYPEA])
        {
            m_prototype[TYPEA] = new ConcretePrototypeA("ConcretePrototypeA");
        }
        if (!m_prototype[TYPEB])
        {
            m_prototype[TYPEB] = new ConcretePrototypeB("ConcretePrototypeB");
        }
    }
    static Prototype* Make(PROTOTYPE_TYPE type)
    {
        if (type >= MAXTYPE)
        {
            return nullptr;
        }
        return m_prototype[type]->Clone();
    }
};

Prototype* ClientPrototype::m_prototype[MAXTYPE];


void TestPrototype(void)
{
    ClientPrototype client;
    client.Init();
    Prototype* a = client.Make(TYPEA);
    Prototype* b = client.Make(TYPEB);
    a->Tell();
    b->Tell();
    delete a;
    delete b;
}