学习设计模式系列之五：原型模式

原型模式：

属于创建型设计模式，直接复制一个已存在的实例作为新实例。

背景补充：

         创建型的设计模式，都属于工厂，内部实现产生实例的方法，对外开放一个获得实例的接口，将产生实例的方法与客户分离，降低耦合度。

         使用原型模式，可以同时使用单例模式产生工厂实例，使用抽象工厂管理生产线，再使用原型模式返回对象。

核心实现：

实现拷贝构造函数。

适用场景：

实例非常复杂，设置非常麻烦，实例的初始化非常耗时；

试图获得实例的客户并没有设置参数的能力，或者不想花费时间去设置参数。

模型类图：

        

图 1 模型图

举例说明：

在本例中，同时使用了抽象工厂，单例模式和原型模式：

工厂实例是通过单例模式创建的；

客户需要的Tank实例是通过原型模式实现的；

对于客户与产品之间的对应是通过抽象工厂模式实现的。

 

图 2 举例类图

代码：

#include <iostream>
#include <vector>
#include <stdlib.h>

/***
* @author:zanzan101
*/

using namespace std;
// 定义枚举类型
enum tank_state
{
    TANK_ATTACK,
    TANK_MOVE,
    TANK_MOVEATTACK,
    TANK_GARD,
    TANK_HOLD
};
enum tank_type
{
    PRISMTANK,
    GRIZZLYTANK,
    RHINOHEAVYTANK
};
// 定义坦克类
class Tank
{
protected:
    int _hp;
    int _damage;
    int _speed;
    int _state;
    int _type;
    int _pos_x;
    int _pos_y;
    bool _dead;
public:

    // 为避免派生类对象造成内存泄漏，需要将析构函数设置为虚函数
    virtual ~Tank(){}
    virtual void set_param(int hp, int da, int sp, int st, int ty, int pos_x, int pos_y, bool dead)
    {
        _hp = hp;
        _damage = da;
        _speed = sp;
        _state = st;
        _type = ty;
        _pos_x = pos_x;
        _pos_y = pos_y;
        _dead = dead;
    }
    virtual void speaking() const =0;
};

class PrismTank: public Tank
{
private:
    char* _chinese_name;
public:
    PrismTank():_chinese_name(0){}

    // 使用原型模式时，如果类对象不适合用浅拷贝的时候，必须实现深拷贝构造函数，如下所示：
    PrismTank(PrismTank& tank)
    {
        _hp = tank._hp;
        _damage = tank._damage;
        _speed = tank._speed;
        _state = tank._state;
        _type = tank._type;
        _pos_x = tank._pos_x;
        _pos_y = tank._pos_y;
        _dead = tank._dead;
        _chinese_name = new char[strlen(tank._chinese_name)+1];
        strcpy(_chinese_name, tank._chinese_name);
    }
    
    // 由于本类对象申请了堆内存，为避免内存泄漏，需要利用多态机制进行析构
    ~PrismTank()
    {
        if(_chinese_name)
            delete _chinese_name;
    }
    void set_param(int hp, int da, int sp, int st, int ty, int pos_x, int pos_y, bool dead, const char* name)
    {
        _hp = hp;
        _damage = da;
        _speed = sp;
        _state = st;
        _type = ty;
        _pos_x = pos_x;
        _pos_y = pos_y;
        _dead = dead;
        _chinese_name = new char[strlen(name)+1];
        strcpy(_chinese_name, name);
    }
    void speaking() const
    {
        cout<< "I'm a Prism Tank! My chinese name is "<< _chinese_name << " My param are hp: "<< _hp << " damage: "<< _damage <<endl;
    }
};

class GrizzlyTank: public Tank
{
public:
    // 如果类适合用浅拷贝，则无需实现拷贝构造函数，系统默认的拷贝构造函数就能完成浅拷贝任务。

    void speaking() const
    {
        cout<< "I'm a Grizzly Tank! My param are hp: "<< _hp << " damage: "<< _damage <<endl;
    }
};

class RhinoHeavyTank: public Tank
{
public:
    RhinoHeavyTank(){}

    // 下面实现的拷贝构造函数，但其实际上默认的一样～
    RhinoHeavyTank(RhinoHeavyTank& tank)
    {
        memcpy(this, &tank, sizeof(RhinoHeavyTank));
    }

    void speaking() const
    {
        cout<< "I'm a Rhino Heavy Tank! My param are hp: "<< _hp << " damage: "<< _damage <<endl;
    }
};

// 使用单例模式创建工厂的实例
class Factory
{
private:

    // 只有静态常量数据才可以在类中直接初始化，例如，下面的初始化是合法的：
    // static const int nothing = 0;

    // 然而，常量非静态数据则不可以直接初始化，例如，下面的初始化是非法的：
    // const int nothing = 0;
    
    // 常量非静态数据需要在“构造函数成员初始值设定项列表”中初始化，例如，下面初始化是合法的：
    // const int nothing;
    // Factory(): nothing(0){}

    static Factory* _instance;
    PrismTank _prism_tank;
    GrizzlyTank _grizzly_tank;
    RhinoHeavyTank _rhino_heavy_tank;
    Factory()
    {
        // 初始化原型实例，这一次初始化之后，后面的实例就是由他们进行拷贝构造
        _prism_tank.set_param(100, 160, 30, TANK_GARD, PRISMTANK, 0, 0, false, "光棱坦克");
        _grizzly_tank.set_param(140, 60, 50, TANK_GARD, GRIZZLYTANK, 0, 0, false);
        _rhino_heavy_tank.set_param(180, 180, 20, TANK_GARD, RHINOHEAVYTANK, 0, 0, false);
    }


public:
    // 获取单例的接口
    static Factory* get_instance()
    {
        if(!_instance)
            _instance = new Factory();
        return _instance;
    }

    // 使用抽象工厂模式设计的对客户的接口，即，客户只需提供型号，而与生产线分离
    Tank* get_prototype_tank(int type)
    {
        switch(type)
        {
        // 对于每一种型号，使用原型模式设计对实例的初始化
        case PRISMTANK:
            return (Tank*)(new PrismTank(_prism_tank));
        case GRIZZLYTANK:
            return (Tank*)(new GrizzlyTank(_grizzly_tank));
        case RHINOHEAVYTANK:
            return (Tank*)(new RhinoHeavyTank(_rhino_heavy_tank));
        default:
            cout<< "ERROR: wrong type !" << endl;
            return 0;
        }
    }
};
Factory* Factory::_instance = 0;

// 设计客户
class Client
{
private:
    Factory* _factory;
public:
    Client()
    {
        _factory = Factory::get_instance();
    }

    // 模拟演示对原型模式的调用方法
    void do_something()
    {
        Tank* tank;

        // 客户调用工厂的接口，获得通过原型模式创建的实例
        tank = _factory->get_prototype_tank(PRISMTANK);
        tank->speaking();
        delete tank;

        tank = _factory->get_prototype_tank(GRIZZLYTANK);
        tank->speaking();
        delete tank;

        tank = _factory->get_prototype_tank(RHINOHEAVYTANK);
        tank->speaking();
        delete tank;
        // 可以看出来上面的tank实例都是拷贝自工厂中的成品对象
    }
};
int _tmain(int argc, _TCHAR* argv[])
{
    Client client;
    client.do_something();

    system("pause");
    return 0;
}

输出结果：

I'm a Prism Tank! My chinese name is 光棱坦克 My param are hp: 100 damage: 160
I'm a Grizzly Tank! My param are hp: 140 damage: 60
I'm a Rhino Heavy Tank! My param are hp: 180 damage: 180
请按任意键继续. . .