学习设计模式系列之三：抽象工厂

抽象工厂简介：

是一种创建对象的方法，当一个类簇的一种派生类对象需要被创建时，只需提供一个接口，并通过参数指定要创建的对象型号，该工厂即可返回该类型对象的指针。

核心：

         将客户和生产线分离。

一般实现方法：

• l  工厂存在一个实例，提供N个接口供客户调用，每个接口负责一个类簇；
• l  工厂依赖全部基类和派生类，并为每一个类簇提供一个接口，当存在N个类簇时，提供N个接口；
• l  客户依赖全部基类，如非特殊情况，客户不依赖派生类；
• l  如果需要添加新的类簇，需要修改：工厂生产方法，工厂接口函数，客户的依赖关系。

优点：

• l  访问该工厂的客户只需要知道自己想要的对象的基类和一个型号参数，即可得到正确的对象，操作简单。
• l  分离了基类和具体类，客户只需要依赖基类，不需要依赖于具体的类。

缺点：

• l  客户可能被欺骗，即工厂返回的不是客户想要的类，客户在不依赖具体类的情况下，无法判别真伪；
• l  当客户依赖于具体类的时候，可以通过向下类型转换从而按派生类去访问，但是如果被欺骗的话将会出现转换失败的情况；
• l  扩展新的类簇是，需要添加生产方法，添加接口，修改客户的依赖关系。

 

图 1 抽象工厂的类图示意图

编程实例：

模拟即时策略游戏中的一方势力的数据结构设计。

其中军队：ArmyList中的对象由抽象工厂模式实现，即：制造坦克和飞机的时候，Camp不需要知道有多少种坦克，他只需要知道坦克类型编号即可生产对应的坦克，飞机同理。

 

图 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
{
    GRIZZLYTANK,
    RHINOHEAVYTANK
};
enum airplane_state
{
    AIRPLANE_ATTACK,
    AIRPLANE_MOVE,
    AIRPLANE_MOVEATTACK,
    AIRPLANE_GARD,
    AIRPLANE_HOLD
};
enum airplane_type
{
    BLACKEAGLE,
    NIGHTHAWK
};
// 定义坦克类
class Tank
{
protected:
    int m_hp;
    int m_damage;
    int m_speed;
    int m_state;
    int m_type;
    int m_pos_x;
    int m_pos_y;
    bool m_dead;
public:
    Tank(): m_hp(0), m_damage(0), m_speed(0), m_state(TANK_GARD), m_type(0), m_pos_x(0), m_pos_y(0), m_dead(false){}
    void attack(Tank* target)
    {
        target->m_hp -= m_damage;
        if(target->m_hp < 0)
        {
            target->m_hp = 0;
            target->set_dead(true);
        }
    }
    void set_dead(bool b = false){m_dead = b;}
    virtual void speaking()=0;
};

class GrizzlyTank: public Tank
{
public:
    GrizzlyTank():Tank()
    {
        m_type = GRIZZLYTANK;
        m_hp = 100;
        m_damage = 80;
        m_speed = 20;
    }
    void speaking()
    {
        cout<< "I'm a Grizzly Tank!" <<endl;
    }
};

class RhinoHeavyTank: public Tank
{
public:
    RhinoHeavyTank():Tank()
    {
        m_type = RHINOHEAVYTANK;
        m_hp = 200;
        m_damage = 50;
        m_speed = 40;
    }
    void speaking()
    {
        cout<< "I'm a Rhino Heavy Tank!" <<endl;
    }
};

// 定义空军类
class Airplane
{
protected:
    int m_hp;
    int m_damage;
    int m_speed;
    int m_state;
    int m_type;
    int m_pos_x;
    int m_pos_y;
    int m_missle_count;
    bool m_fly;
    bool m_dead;
public:
    Airplane(): m_hp(0), m_damage(0), m_speed(0), m_state(TANK_GARD), m_type(0), m_pos_x(0), m_pos_y(0), m_missle_count(0), m_fly(false), m_dead(false){}
    void attack(Airplane* target)
    {
        if(m_missle_count == 0)
            return;
        target->m_hp -= m_damage;
        if(target->m_hp < 0)
        {
            target->m_hp = 0;
            target->set_dead(true);
        }
    }
    void set_dead(bool b = false){m_dead = b;}
    virtual void speaking()=0;
};

class BlackEagle: public Airplane
{
public:
    BlackEagle():Airplane()
    {
        m_type = BLACKEAGLE;
        m_hp = 60;
        m_damage = 120;
        m_speed = 100;
        m_missle_count = 4;
    }
    void speaking()
    {
        cout<< "I'm a BlackEagle!" <<endl;
    }
};

class NightHawk: public Airplane
{
public:
    NightHawk():Airplane()
    {
        m_type = NIGHTHAWK;
        m_hp = 40;
        m_damage = 80;
        m_speed = 160;
        m_missle_count = 1;
    }
    void speaking()
    {
        cout<< "I'm a NightHawk!" <<endl;
    }
};

// 定义生产线
class VehichleFactory
{
public:
    // 定义抽象工厂对客户开放的接口
    static Tank* get_tank(int tank_type)
    {
        if(GRIZZLYTANK == tank_type)
            return new GrizzlyTank();
        else if(RHINOHEAVYTANK == tank_type)
            return new RhinoHeavyTank();
    }

    // 定义抽象工厂对客户开放的接口
    static Airplane* get_airplane(int airplane_type)
    {
        if(BLACKEAGLE == airplane_type)
            return new BlackEagle();
        else if(NIGHTHAWK == airplane_type)
            return new NightHawk();
    }
};
class BuildingList
{
    // 略
};

class Money
{
    // 略
};

class Camp;
class ArmyList
{
    friend Camp;
private:
    vector<Tank*> m_tanks;
    vector<Airplane*> m_airplanes;
public:
    ArmyList(){}
    ~ArmyList()
    {
        // 释放指针所指内存空间
        for(int i = 0; i < m_tanks.size(); i++)
        {
            delete m_tanks[i];
            m_tanks[i] = 0;
        }
        vector<Tank*>().swap(m_tanks);

        // 释放指针所指内存空间
        for(int i = 0; i < m_airplanes.size(); i++)
        {
            delete m_airplanes[i];
            m_airplanes[i] = 0;
        }
        vector<Airplane*>().swap(m_airplanes);
    }
    void add_tank(int tank_type, int count=1)
    {
        while(count-- > 0)
            m_tanks.push_back(VehichleFactory::get_tank(tank_type));                // 调用抽象工厂的接口
    }
    void add_airplane(int airplane_type, int count=1)
    {
        while(count-- > 0)
            m_airplanes.push_back(VehichleFactory::get_airplane(airplane_type));    // 调用抽象工厂的接口
    }
    void speaking()
    {
        for(int i = 0; i < m_tanks.size(); i++)
            m_tanks[i]->speaking();
        for(int i = 0; i < m_airplanes.size(); i++)
            m_airplanes[i]->speaking();
    }
};

class Camp
{
private:
    BuildingList m_buildinglist;
    Money m_money;
    ArmyList m_armylist;
public:
    void do_something()
    {
        // 模拟一些操作行为
        m_armylist.add_tank(GRIZZLYTANK);
        m_armylist.add_tank(RHINOHEAVYTANK, 3);
        m_armylist.add_airplane(BLACKEAGLE, 2);
        m_armylist.add_airplane(NIGHTHAWK);
        m_armylist.speaking();
    }
};


int _tmain(int argc, _TCHAR* argv[])
{
    Camp camp;
    camp.do_something();
    system("pause");
    return 0;
}

输出结果：

I'm a Grizzly Tank!
I'm a Rhino Heavy Tank!
I'm a Rhino Heavy Tank!
I'm a Rhino Heavy Tank!
I'm a BlackEagle!
I'm a BlackEagle!
I'm a NightHawk!
请按任意键继续. . .