设计模式之工厂模式与抽象工厂模式(代码)

// 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();
}

转载于:https://www.cnblogs.com/Trustable/archive/2012/12/05/2804157.html