用代码和UML图化解设计模式之《抽象工厂模式》

/************************************************************************/
/* @filename    abstractFactory.cpp
04.   @author       wallwind
05.   @createtime    2012/10/21 00:40
06.   @function      抽象工厂模式
07.   @email       wochenglin@qq.com
08.*/
/************************************************************************/

#include "stdafx.h"
#include <iostream>

using namespace std;

//用户类
class User
{
public:
User (){}
virtual ~User (){}

virtual void attack() = 0;

virtual void defense() = 0;

};
//怪物类
class Monster
{
public:
Monster (){}
virtual ~Monster (){}

virtual void attack() = 0;

virtual void defense() = 0;

};
//宠物类
class Pet
{
public:
Pet (){}
virtual ~Pet (){}

virtual void attack() = 0;

virtual void defense() = 0;

};

//游戏中还有很多角色。比如刀客，异人等

class SwordUser:public User
{
public:

SwordUser(){}
~SwordUser(){}

void attack()
{
cout<<"SwordUser:attack"<<endl;
}

void defense()
{
cout<<"SwordUser:defense"<<endl;
}

};

class SpecialUser:public User
{
public:

SpecialUser(){}
~SpecialUser(){}

void attack()
{
cout<<"SpecialUser:attack"<<endl;
}

void defense()
{
cout<<"SpecialUser:defense"<<endl;
}

};
//////怪物氛围一般的怪物，和BOSS类。

class GeneralMonster:public Monster
{
public:

GeneralMonster(){}
~GeneralMonster(){}

void attack()
{
cout<<"GeneralMonster:attack"<<endl;
}

void defense()
{
cout<<"GeneralMonster:defense"<<endl;
}

};

class BossMonster:public Monster
{
public:

BossMonster(){}
~BossMonster(){}

void attack()
{
cout<<"BossMonster:attack"<<endl;
}

void defense()
{
cout<<"BossMonster:defense"<<endl;
}

};

////宠物很多种，比如用来进攻的。还有用来骑得等等
class AttackPet:public Pet
{
public:

AttackPet(){}
~AttackPet(){}

void attack()
{
cout<<"AttackPet:attack"<<endl;
}

void defense()
{
cout<<"AttackPet:defense"<<endl;
}

};

class GeneralPet:public Pet
{
public:

GeneralPet(){}
~GeneralPet(){}

void attack()
{
cout<<"GeneralPet:attack"<<endl;
}

void defense()
{
cout<<"GeneralPet:defense"<<endl;
}

};

////抽象工厂类

class AbstractFactory
{
public:
AbstractFactory(){}
virtual ~AbstractFactory(){}

virtual User * createUser() = 0;
virtual Monster* createMonster() = 0;
virtual Pet* createPet() = 0;
};

class SpecialFactory: public AbstractFactory
{
public :
SpecialFactory(){}
~SpecialFactory(){}
User* createUser()
{
User *retUser;
retUser = new SwordUser();
return retUser;
}

Monster* createMonster()
{
Monster* retMonster;
retMonster = new BossMonster();
return retMonster;

}

Pet* createPet()
{
Pet* retPet;
retPet = new AttackPet();
return retPet;
}

};

class GeneralFactory: public AbstractFactory
{
public :
GeneralFactory(){}
~GeneralFactory(){}
User* createUser()
{
User *retUser;
retUser = new SpecialUser();
return retUser;
}

Monster* createMonster()
{
Monster* retMonster;
retMonster = new GeneralMonster();
return retMonster;

}

Pet* createPet()
{
Pet* retPet;
retPet = new GeneralPet();
return retPet;
}

};

class  RoleCreate
{
public:
RoleCreate(AbstractFactory* af):m_role(af){}
~RoleCreate()
{
if (m_role!=NULL)
{
delete m_role;
}
}
void factory()
{
m_role->createUser()->attack();
m_role->createMonster()->attack();
m_role->createPet()->attack();
}
private:
AbstractFactory* m_role;

};
int _tmain(int argc, _TCHAR* argv[])
{

AbstractFactory* factory;

factory= new SpecialFactory();
RoleCreate role(factory);
role.factory();

factory = new GeneralFactory();
RoleCreate role1(factory);
role1.factory();

if (factory!=NULL)
{
delete factory;
factory =NULL;
}
return 0;
}