c++模拟实现对象池

怪物基类： 

#pragma once
//怪物枚举

enum MonsterType{
	PMONSTER,
	MMONSTER,
	HMONSTER
};
class Monster
{
public:
	virtual void display()=0;
	Monster()
	{
	}
	virtual ~Monster()//虚析构
	{
	}
	MonsterType getType()const
	{
		return type;
	}
private:
	MonsterType type;//怪物类型
};

三个子类怪物：

#pragma once
#include "Monster.h"
#include <iostream>
class HMonster :
	public Monster
{
public:
	void display()
	{
		std::cout << "H_Monster" << std::endl;
	}
	HMonster();
	~HMonster();
};


#pragma once
#include "Monster.h"
#include <iostream>
class MMonster :
	public Monster
{
public:
	void display()
	{
		std::cout << "M_Monster" << std::endl;
	}
	MMonster();
	~MMonster();
};


#pragma once
#include "Monster.h"
#include <iostream>
class PMonster :
	public Monster
{
public:
	void display()
	{
		std::cout << "P_Monster" << std::endl;
	}
	PMonster();
	~PMonster();
};

怪物管理类：

#pragma once
#include<list>
class Monster;
enum MonsterType;
class MonsterManager
{
public:
	static MonsterManager* getInstance()
	{
		if (pInatance == nullptr)
			pInatance = new MonsterManager;
		return pInatance;
	}
	~MonsterManager();
public:
	void addMonster(Monster* monster);//1.添加到生成池中
	void collection(Monster* monster);//2.回收到死亡池中
	Monster* findInDeath(MonsterType type);//3.在死亡池中查找
private:
	static MonsterManager* pInatance;
	MonsterManager();
	std::list<Monster*>lives;
	std::list<Monster*>deaths;
};


#include "MonsterManager.h"
#include "Monster.h"
MonsterManager* MonsterManager::pInatance = nullptr;
MonsterManager::MonsterManager()
{
}
void MonsterManager::addMonster(Monster* monster){
	lives.push_back(monster);
}
void MonsterManager::collection(Monster* monster)
{
	//从生存池中移除
	lives.remove(monster);
	//加入死亡池
	deaths.push_back(monster);

}
Monster* MonsterManager::findInDeath(MonsterType type)
{
	Monster* monster = nullptr;
	if (deaths.empty())
		return monster;
	for (Monster* mon : deaths)
	{
		if (mon->getType() == type){
			monster = mon;
			break;
		}
	}
	//将符合条件的从死亡池中移除
	deaths.remove(monster);
	return monster;
}
MonsterManager::~MonsterManager()
{
	pInatance = nullptr;
	//释放所有的怪物内存
	for (Monster* monster : lives){
		delete monster;
		monster = nullptr;
	}
	for (Monster* monster : deaths){
		delete monster;
		monster = nullptr;
	}
	lives.clear();
	deaths.clear();
	//清空链表
}

工厂类：

#pragma once
class Monster;
enum MonsterType;

//简单工厂模式：创建对象
class MonsterFactory
{
public:
	MonsterFactory();
	~MonsterFactory();
	static Monster* create(MonsterType type);//根据类型创建怪物
};


#include "MonsterFactory.h"
#include "MonsterManager.h"
#include "Monster.h"
#include "PMonster.h"
#include "HMonster.h"
#include "MMonster.h"
MonsterFactory::MonsterFactory()
{
}

MonsterFactory::~MonsterFactory()
{
}
Monster* MonsterFactory::create(MonsterType type){
	Monster* monster = nullptr;
	MonsterManager* pManager = MonsterManager::getInstance();
	//1.先在死亡池查找符合条件的怪物
	monster = pManager->findInDeath(type);
	//2.如果没有找到,new一个对应的怪物
	if (monster == nullptr)
	{
		switch (type){
		case PMONSTER:
			//monster=new Monster
			monster = new PMonster();
			break;
		case MMONSTER:
			monster = new MMonster();
			break;
		case HMONSTER:
			monster = new HMonster();
			break; 
		default:break;
		}
	}
	pManager->addMonster(monster);
	return monster;
}

main函数：

#include "Monster.h"
#include "MonsterFactory.h"
#include <iostream>
using namespace std;
int main(){
	int choice = 0;
	Monster* monster;
	while (cin >> choice){
		monster = MonsterFactory::create((MonsterType)choice);
		monster->display();
	}
	return 0;
}