设计模式之工厂模式与抽象工厂模式(代码)
// Monster.h: interface for the CMonster class.
//
//////////////////////////////////////////////////////////////////////
//怪物祖先类
class CMonster
{
private:
char* name;
public:
virtual ~CMonster();
int attack();
protected:
CMonster();
};
class CHighLevelMonster :public CMonster{
protected:
CHighLevelMonster();
public:
virtual ~CHighLevelMonster();
};
class CMiddleLevelMonster :public CMonster{
protected:
CMiddleLevelMonster();
public:
virtual ~CMiddleLevelMonster();
};
class CLowLevelMonster :public CMonster{
protected:
CLowLevelMonster();
public:
virtual ~CLowLevelMonster();
};
//高级的马
class CHighLevelHorse :public CHighLevelMonster{
public:
CHighLevelHorse();
virtual ~CHighLevelHorse();
};
//中级的马
class CMiddleLevelHorse :public CMiddleLevelMonster{
public:
CMiddleLevelHorse();
virtual ~CMiddleLevelHorse();
};
//低级的马
class CLowLevelHorse :public CLowLevelMonster{
public:
CLowLevelHorse();
virtual ~CLowLevelHorse();
};
//高级的蜘蛛
class CHighLevelSpiter :public CHighLevelMonster{
public:
CHighLevelSpiter();
virtual ~CHighLevelSpiter();
};
//中级的蛛蛛
class CMiddleLevelSpiter :public CMiddleLevelMonster{
public:
CMiddleLevelSpiter();
virtual ~CMiddleLevelSpiter();
};
//低级的蛛蛛
class CLowLevelSpiter :public CLowLevelMonster{
public:
CLowLevelSpiter();
virtual ~CLowLevelSpiter();
};
//高级的猴子
class CHighLevelMonkey :public CHighLevelMonster{
public:
CHighLevelMonkey();
virtual ~CHighLevelMonkey();
};
//中级的猴子
class CMiddleLevelMonkey :public CMiddleLevelMonster{
public:
CMiddleLevelMonkey();
virtual ~CMiddleLevelMonkey();
};
//低级的猴子
class CLowLevelMonkey :public CLowLevelMonster{
public:
CLowLevelMonkey();
virtual ~CLowLevelMonkey();
};
// Monster.cpp: implementation of the CMonster class.
//
//////////////////////////////////////////////////////////////////////
#include "Monster.h"
#include <iostream>
using namespace std;
CMonster::CMonster()
{
}
CMonster::~CMonster()
{
}
CHighLevelMonster::CHighLevelMonster()
{
}
CHighLevelMonster::~CHighLevelMonster()
{
}
CMiddleLevelMonster::CMiddleLevelMonster()
{
}
CMiddleLevelMonster::~CMiddleLevelMonster()
{
}
CLowLevelMonster::CLowLevelMonster()
{
}
CLowLevelMonster::~CLowLevelMonster()
{
}
CHighLevelHorse::CHighLevelHorse()
{
cout<<"a high level Horse constructed!\r\n"<<endl;
}
CMiddleLevelHorse::CMiddleLevelHorse()
{
cout<<"a middle level Horse constructed!\r\n"<<endl;
}
CLowLevelHorse::CLowLevelHorse()
{
cout<<"a low level Horse constructed!\r\n"<<endl;
}
CHighLevelHorse::~CHighLevelHorse()
{
}
CMiddleLevelHorse::~CMiddleLevelHorse()
{
}
CLowLevelHorse::~CLowLevelHorse()
{
}
CHighLevelMonkey::CHighLevelMonkey()
{
cout<<"a high level monkey constructed!\r\n"<<endl;
}
CMiddleLevelMonkey::CMiddleLevelMonkey()
{
cout<<"a middel level monkey constructed!\r\n"<<endl;
}
CLowLevelMonkey::CLowLevelMonkey()
{
cout<<"a low level monkey constructed!\r\n"<<endl;
}
CHighLevelMonkey::~CHighLevelMonkey(){}
CMiddleLevelMonkey::~CMiddleLevelMonkey(){}
CLowLevelMonkey::~CLowLevelMonkey(){}
CHighLevelSpiter::CHighLevelSpiter()
{
cout<<"a high level spiter constructed!\r\n"<<endl;
}
CMiddleLevelSpiter::CMiddleLevelSpiter()
{
cout<<"a middle level spiter constructed!\r\n"<<endl;
}
CLowLevelSpiter::CLowLevelSpiter()
{
cout<<"a low level spiter constructed!\r\n"<<endl;
}
CHighLevelSpiter::~CHighLevelSpiter(){}
CMiddleLevelSpiter::~CMiddleLevelSpiter(){}
CLowLevelSpiter::~CLowLevelSpiter(){}
// Factory.h: interface for the CFactory class.
//
//////////////////////////////////////////////////////////////////////
/************************************************************************/
/************************************************************************/
class CHighLevelMonster;
class CMiddleLevelMonster;
class CLowLevelMonster;
class CFactory
{
public:
virtual ~CFactory();
virtual CHighLevelMonster* getHighLevelMonster() = 0;
virtual CMiddleLevelMonster* getMiddleLevelMonster() = 0 ;
virtual CLowLevelMonster* getLowLevelMonster() = 0;
protected:
CFactory();
};
class CMonkeyFactory :public CFactory
{
public:
CMonkeyFactory();
virtual ~CMonkeyFactory();
CHighLevelMonster* getHighLevelMonster();
CMiddleLevelMonster* getMiddleLevelMonster();
CLowLevelMonster* getLowLevelMonster();
};
class CHorseFactory :public CFactory
{
public:
CHorseFactory();
virtual ~CHorseFactory();
CHighLevelMonster* getHighLevelMonster();
CMiddleLevelMonster* getMiddleLevelMonster();
CLowLevelMonster* getLowLevelMonster();
};
class CSpiterFactory :public CFactory
{
public:
CSpiterFactory();
virtual ~CSpiterFactory();
CHighLevelMonster* getHighLevelMonster();
CMiddleLevelMonster* getMiddleLevelMonster();
CLowLevelMonster* getLowLevelMonster();
};
// Factory.cpp: implementation of the CFactory class.
//
//////////////////////////////////////////////////////////////////////
#include "Factory.h"
#include "Monster.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CFactory::CFactory()
{
}
CFactory::~CFactory()
{
}
/////////////////////////////////////////////////////////////////////
CMonkeyFactory::CMonkeyFactory()
{
}
CMonkeyFactory::~CMonkeyFactory()
{
}
CHighLevelMonster* CMonkeyFactory::getHighLevelMonster()
{
return new CHighLevelMonkey();
}
CMiddleLevelMonster* CMonkeyFactory::getMiddleLevelMonster()
{
return new CMiddleLevelMonkey();
}
CLowLevelMonster* CMonkeyFactory::getLowLevelMonster()
{
return new CLowLevelMonkey();
}
/////////////////////////////////////////////////////////////////////
CHorseFactory::CHorseFactory()
{
}
CHorseFactory::~CHorseFactory()
{
}
CHighLevelMonster* CHorseFactory::getHighLevelMonster()
{
return new CHighLevelHorse();
}
CMiddleLevelMonster* CHorseFactory::getMiddleLevelMonster()
{
return new CMiddleLevelHorse();
}
CLowLevelMonster* CHorseFactory::getLowLevelMonster()
{
return new CLowLevelHorse();
}
/////////////////////////////////////////////////////////////////////
CSpiterFactory::CSpiterFactory()
{
}
CSpiterFactory::~CSpiterFactory()
{
}
CHighLevelMonster* CSpiterFactory::getHighLevelMonster()
{
return new CHighLevelSpiter();
}
CMiddleLevelMonster* CSpiterFactory::getMiddleLevelMonster()
{
return new CMiddleLevelSpiter();
}
CLowLevelMonster* CSpiterFactory::getLowLevelMonster()
{
return new CLowLevelSpiter();
}