高人来解疑抽象工厂模式

我给你举一个例子，仔细琢磨一下。#include <iostream>
#include <fstream>using namespace std;//士兵抽象出来
class Soldier
{
public:
    virtual void Fight() = 0;
};//愚蠢的士兵
class SillySoldier : public Soldier
{
public:
    virtual void Fight()
    {
        cout << "Silly Fight!" << endl;
    }
};//强悍的士兵
class BadSoldier : public Soldier
{
public:
    virtual void Fight()
    {
        cout << "Bad Fight!" << endl;
    }
};//怪兽抽象出来
class Monster
{
public:
    virtual void Attack() = 0;
};//强悍的怪兽
class BadMonster : public Monster
{
public:
    virtual void Attack()
    {
        cout << "Bad Attack!" << endl;
    }
};//愚蠢的怪兽
class SillyMonster : public Monster
{
public:
    virtual void Attack()
    {
        cout << "Silly Attack!" << endl;
    }
};//超级怪兽抽象出来
class SuperMonster
{
public:
    virtual void SuperAttack() = 0;
};//愚蠢的超级怪兽
class SillySuperMonster : public SuperMonster
{
public:
    virtual void SuperAttack()
    {
        cout << "Silly SuperAttack!" << endl;
    }
};//强悍的超级怪兽
class BadSuperMonster : public SuperMonster
{
public:
    virtual void SuperAttack()
    {
        cout << "Bad SuperAttack!" << endl;
    }
};
//抽象工厂
class AbstractEnemyFactory
{
public:
    virtual Soldier* MakeSoldier() = 0;
    virtual Monster* MakeMonster() = 0;
    virtual SuperMonster* MakeSuperMonster() = 0;
};//简单任务中使用的工厂
class EasyLevelEnemyFactory : public AbstractEnemyFactory
{
public:
    Soldier* MakeSoldier() { return new SillySoldier; }
    Monster* MakeMonster() { return new SillyMonster; }
    SuperMonster* MakeSuperMonster() { return new SillySuperMonster; }
};//困难任务中使用的工厂
class DieHardLevelEnemyFactory : public AbstractEnemyFactory
{
public:
    Soldier* MakeSoldier() { return new BadSoldier; }
    Monster* MakeMonster() { return new BadMonster; }
    SuperMonster* MakeSuperMonster() { return new BadSuperMonster; }
};//游戏类
class GameApp
{
public:
    void SelectLevel(int i)
    {
        if (i == 1)
            _Fatctory = new EasyLevelEnemyFactory;
        else
            _Fatctory = new DieHardLevelEnemyFactory;
    }

    void Run()
    {
        Soldier *soldier = _Fatctory->MakeSoldier();
        Monster *monster = _Fatctory->MakeMonster();
        SuperMonster *superMonster = _Fatctory->MakeSuperMonster();

        soldier->Fight();
        monster->Attack();
        superMonster->SuperAttack();

        delete soldier;
        delete monster;
        delete superMonster;
    }

    GameApp(AbstractEnemyFactory* _Fatctory = NULL):_Fatctory(NULL){}

    ~GameApp()
    {
        if(_Fatctory != NULL) delete _Fatctory;
    }

private:
    AbstractEnemyFactory* _Fatctory;
};int main()
{
    GameApp app;
    app.SelectLevel(1);
    app.Run();

    app.SelectLevel(0);
    app.Run();
return 0;
}

#include <fstream>
可以去掉！

太看得起这个例子了！那就扩展一下：#include<iostream>
using namespace std;
class Role
{
public: virtual void Function()= 0;;
}; class ConcreteSoldier:public Role
{
public: ConcreteSoldier()
        { cout<<"创建士兵"<<endl; }
public: virtual ~ConcreteSoldier(void)
        { cout<<"士兵阵亡"<<endl; }
public: virtual void Function()
        { cout<<"士兵身穿盔甲，手握武器，能杀怪兽"<<endl; }
}; class ConcreteMonster:public Role
{
public: ConcreteMonster(void)
        { cout<<"创建怪兽"<<endl; }
public: virtual ~ConcreteMonster(void)
        { cout<<"怪兽阵亡"<<endl; }
public: virtual void Function()
        { cout<<"怪兽体态庞大，能攻击士兵，伤害较小"<<endl; }
};
class ConcreteSuperMonster:public Role
{
public: ConcreteSuperMonster(void)
        { cout<<"创建超级怪兽"<<endl; }
public: virtual ~ConcreteSuperMonster(void)
        { cout<<"超级怪兽阵亡"<<endl; }
public: virtual void Function()
        { cout<<"超级怪兽血量超长，能攻击士兵，造成较大伤害"<<endl; }
};
class ConcreteNPC:public Role
{
public: ConcreteNPC(void)
        { cout<<"NPC出场"<<endl; }
public: virtual ~ConcreteNPC(void)
        { cout<<"NPC退场"<<endl; }
public: virtual void Function()
        { cout<<"NPC提供支线或主线情节"<<endl; }
};
class Factory
{
public: Factory(){}
public: ~Factory(){}
public: virtual Role *CreateRole(int RoleType=0)=0;
};
class ConcreteFactory1:public Factory
{
public:ConcreteFactory1(){}
public:virtual ~ConcreteFactory1(){}
public :Role* CreateRole(int RoleType)
        {
            Role *p = 0;
            switch(RoleType)
            { case 0: p= new ConcreteSoldier();break;
            case 1: p= new ConcreteMonster(); break;
            case 2: p= new ConcreteSuperMonster(); break;
            default: p= new ConcreteSoldier();break;
            }
            return p;
        }
};
class ConcreteFactory2:public Factory
{
public: ConcreteFactory2(){}
public: virtual ~ConcreteFactory2(){}
public : Role* CreateRole(int RoleType=0)
         {
             return new ConcreteNPC();

         }
}; void main()
{
    cout<<"工厂模式实例"<<endl;
    cout<<"要点：把New对象的权限延迟到工厂子类进行"<<endl;
    cout<<"方案：1)实现雷同简单工厂"<<endl;
    cout<<"      2)利用多态，为每一个要创建的子类都创建一个对应工厂"<<endl;
    cout<<"和简单工厂的比较："<<endl;
    cout<<"  1)把工厂进行了抽象，具体加工产品，有子类实现"<<endl;
    cout<<"  2)对于基类不明确要创建的具体什么对象的适应性广"<<endl;
    cout<<"运行"<<endl;

    Factory*fct = new ConcreteFactory1();
    Role *p = fct->CreateRole(0);

    p->Function();
    delete p;
    p = fct->CreateRole(1);
    p->Function();
    delete p;
    p = fct->CreateRole(2);
    p->Function();
    delete p;
    delete fct;

    fct = new ConcreteFactory2();
    p=fct->CreateRole(0);
    p->Function();
    delete p;
    delete fct;

    cout<<"工厂模式运行完毕"<<endl<<endl;

}
/*抽象工厂*/
C/C++ code
#include<iostream>
using namespace std;
//角色基类
class Role
{
public: virtual void Function()= 0;;
};
//士兵基类
class ConcreteSoldier:public Role
{
public: ConcreteSoldier()
        { cout<<"创建士兵"<<endl; }
public: virtual ~ConcreteSoldier(void)
        { cout<<"士兵阵亡"<<endl; }
public: virtual void Function()
        { cout<<"士兵身穿盔甲，手握武器，能杀怪兽"<<endl; }
};
//简单级别士兵类
class ConcreteSoldier1:public ConcreteSoldier
{
public: ConcreteSoldier1()
        { cout<<"创建简单级别士兵"<<endl; }
public: virtual ~ConcreteSoldier1(void)
        { cout<<"简单级别士兵阵亡"<<endl; }
public: virtual void Function()
        { cout<<"简单级别中：士兵身穿布衣，手持木剑，武功一般般"<<endl; }
};
//普通级别士兵类
class ConcreteSoldier2:public ConcreteSoldier
{
public: ConcreteSoldier2()
        { cout<<"创建普通级别士兵"<<endl; }
public: virtual ~ConcreteSoldier2(void)
        { cout<<"普通级别士兵阵亡"<<endl; }
public: virtual void Function()
        { cout<<"普通级别中：士兵身穿藤衣，手持铁剑，武功尚可"<<endl; }
};
//困难级别士兵类
class ConcreteSoldier3:public ConcreteSoldier
{
public: ConcreteSoldier3()
        { cout<<"创建困难级别士兵"<<endl; }
public: virtual ~ConcreteSoldier3(void)
        { cout<<"困难级别士兵阵亡"<<endl; }
public: virtual void Function()
        { cout<<"困难级别中：士兵身穿软胄，手持削铁如泥宝剑，武功不错"<<endl; }
};
//怪兽基类
class ConcreteMonster:public Role
{
public: ConcreteMonster(void)
        { cout<<"创建怪兽"<<endl; }
public: virtual ~ConcreteMonster(void)
        { cout<<"怪兽阵亡"<<endl; }
public: virtual void Function()
        { cout<<"怪兽体态庞大，能攻击士兵，伤害较小"<<endl; }
};
//简单级别怪兽类
class ConcreteMonster1:public ConcreteMonster
{
public: ConcreteMonster1(void)
        { cout<<"创建简单级别怪兽"<<endl; }
public: virtual ~ConcreteMonster1(void)
        { cout<<"简单级别怪兽阵亡"<<endl; }
public: virtual void Function()
        { cout<<"简单级别怪兽体态小，攻击力小，反应迟钝"<<endl; }
};
//普通级别怪兽类
class ConcreteMonster2:public ConcreteMonster
{
public: ConcreteMonster2(void)
        { cout<<"创建普通级别怪兽"<<endl; }
public: virtual ~ConcreteMonster2(void)
        { cout<<"普通级别怪兽阵亡"<<endl; }
public: virtual void Function()
        { cout<<"普通级别怪兽体态适中，具有一定灵活性，攻击力中"<<endl; }
};
//困难级别怪兽类
class ConcreteMonster3:public ConcreteMonster
{
public: ConcreteMonster3(void)
        { cout<<"创建困难级别怪兽"<<endl; }
public: virtual ~ConcreteMonster3(void)
        { cout<<"困难级别怪兽阵亡"<<endl; }
public: virtual void Function()
        { cout<<"困难级别怪兽体态庞大，灵活性高，伤害较大，会补血"<<endl; }
};

//超级怪兽基类
class ConcreteSuperMonster:public Role
{
public: ConcreteSuperMonster(void)
        { cout<<"创建超级怪兽"<<endl; }
public: virtual ~ConcreteSuperMonster(void)
        { cout<<"超级怪兽阵亡"<<endl; }
public: virtual void Function()
        { cout<<"超级怪兽血量超长，能攻击士兵，造成较大伤害"<<endl; }
};
//简单级别超级怪兽类
class ConcreteSuperMonster1:public ConcreteSuperMonster
{
public: ConcreteSuperMonster1(void)
        { cout<<"创建简单级别超级怪兽"<<endl; }
public: virtual ~ConcreteSuperMonster1(void)
        { cout<<"简单级别超级怪兽阵亡"<<endl; }
public: virtual void Function()
        { cout<<"简单级别的超级怪兽血量一般长，造成较大伤害，最多使用1次回复术"<<endl; }
};
//普通级别超级怪兽类
class ConcreteSuperMonster2:public ConcreteSuperMonster
{
public: ConcreteSuperMonster2(void)
        { cout<<"创建普通级别超级怪兽"<<endl; }
public: virtual ~ConcreteSuperMonster2(void)
        { cout<<"普通级别超级怪兽阵亡"<<endl; }
public: virtual void Function()
        { cout<<"普通级别的超级怪兽血量较长，造成较大伤害，最多使用2次回复术，会使用必杀技"<<endl; }
};
//困难级别超级怪兽类
class ConcreteSuperMonster3:public ConcreteSuperMonster
{
public: ConcreteSuperMonster3(void)
        { cout<<"创建困难级别超级怪兽"<<endl; }
public: virtual ~ConcreteSuperMonster3(void)
        { cout<<"困难级别超级怪兽阵亡"<<endl; }
public: virtual void Function()
        { cout<<"困难级别的超级怪兽血量超长，造成较大伤害，最多使用3次回复术，会召唤同伴"<<endl; }
};
//NPC基类
class ConcreteNPC:public Role
{
public: ConcreteNPC(void)
        { cout<<"NPC出场"<<endl; }
public: virtual ~ConcreteNPC(void)
        { cout<<"NPC退场"<<endl; }
public: virtual void Function()
        { cout<<"NPC提供支线或主线情节"<<endl; }
};
//抽象工厂
class AbstractFactory
{
public: AbstractFactory(){}
public: ~AbstractFactory(){}
public: virtual ConcreteSoldier* CreateSoldier() = 0;
public: virtual ConcreteMonster* CreateMonster() = 0;
public: virtual ConcreteSuperMonster* CreateSuperMonster() = 0;
};
//具体工厂-简单级别
class ConcreteFactory1:public AbstractFactory
{
public:
    ConcreteFactory1(){}
public:
    virtual ~ConcreteFactory1(){}
public :
    virtual  ConcreteSoldier* CreateSoldier()
    {
        return new ConcreteSoldier1();
    }
public :
    virtual  ConcreteMonster* CreateMonster()
    {
        return new ConcreteMonster1();
    }
public :
    virtual  ConcreteSuperMonster* CreateSuperMonster()
    {
        return new ConcreteSuperMonster1();
    }
}; //具体工厂-普通级别
class ConcreteFactory2:public AbstractFactory
{
public:
    ConcreteFactory2(){}
public:
    virtual ~ConcreteFactory2(){}
public :
    virtual  ConcreteSoldier* CreateSoldier()
    {
        return new ConcreteSoldier2();
    }
public :
    virtual  ConcreteMonster* CreateMonster()
    {
        return new ConcreteMonster2();
    }
public :
    virtual ConcreteSuperMonster* CreateSuperMonster()
    {
        return new ConcreteSuperMonster2();
    }
};
//具体工厂-困难级别
class ConcreteFactory3:public AbstractFactory
{
public:
    ConcreteFactory3(){}
public:
    virtual ~ConcreteFactory3(){}
public :
    virtual  ConcreteSoldier* CreateSoldier()
    {
        return new ConcreteSoldier3();
    }
public :
    virtual  ConcreteMonster* CreateMonster()
    {
        return new ConcreteMonster3();
    }
public :
    virtual  ConcreteSuperMonster* CreateSuperMonster()
    {
        return new ConcreteSuperMonster3();
    }
};
void main()
{
    cout<<"抽象工厂模式实例"<<endl;
    cout<<"问题引入：多套对象的创建。例如下列情况："<<endl;
    cout<<"1) 用户要求两套不同风格的控件"<<endl;
    cout<<"2) 游戏中不同难度的一系列关口"<<endl;
    cout<<"特征：每一个工厂实例都产生一系列的产品。在一个工厂实例中加工产品方法的返回值不同"<<endl;
    cout<<"  当然，它们可以是共同基类继承而来，但在此模式中，关心和体现出来的是它们的不同点"<<endl;
    cout<<"  因此如果它们的返回值类型从共同基类继承，并返回此基类，就退化为工厂模式了，依照"<<endl;
    cout<<"  此特征因此工厂模式是抽象工厂模式的特例，可以近似认为抽象工厂是不同工厂聚合而成"<<endl;
    cout<<"运行"<<endl<<endl;

    AbstractFactory *absfct = new ConcreteFactory1();
    ConcreteSoldier *cpa = absfct->CreateSoldier();
    cpa->Function();
    delete cpa;
    ConcreteMonster *cpb = absfct->CreateMonster();
    cpb->Function();
    delete cpb;
    ConcreteSuperMonster *cpc = absfct->CreateSuperMonster();
    cpc->Function();
    delete cpc;
    delete absfct;
    absfct = new ConcreteFactory2();
    cpa = absfct->CreateSoldier();
    cpa->Function();
    delete cpa;
    cpb = absfct->CreateMonster();
    cpb->Function();
    delete cpb;
    cpc = absfct->CreateSuperMonster();
    cpc->Function();
    delete cpc;
    delete absfct;
    absfct = new ConcreteFactory3();
    cpa = absfct->CreateSoldier();
    cpa->Function();
    delete cpa;
    cpb = absfct->CreateMonster();
    cpb->Function();
    delete cpb;
    cpc = absfct->CreateSuperMonster();
    cpc->Function();
    delete cpc;
    delete absfct;
    cout<<"结束"<<endl<<endl;
}

调试易

高人来解疑抽象工厂模式

解决方案 »