抽象工厂

抽象工厂

抽象工厂，比简单工厂功能更复杂了一点。抽象工厂能做更复杂的事情。抽象工厂需要一个抽象工厂。继承他的子工厂。抽象产品类。这跟简单工厂差不多。唯一的区别的多了一个抽象工厂类。具体的工厂。既然如此。我们为什么还要写抽象工厂类，不是也可以多写几个工厂，这不就可以解决问题了。引入抽象工厂目的是为了实现多态。继承的目的就是为了实现多态。下面这个例子更好的理解

抽象工厂

#pragma once
#include"WildWolf.h"
#include"WildBoar.h"
class MonsterFactory
{
public:
	virtual WildWolf* createWildWolfMonster() = 0;
	virtual WildBoar* createWildBoarMonster() = 0;
};

简单工厂
-------------------------------头文件----------------------------
#pragma once
#include "MonsterFactory.h"
class PrimaryFactoy :
	public MonsterFactory
{

	virtual WildWolf* createWildWolfMonster();
	virtual WildBoar* createWildBoarMonster();
};

-------------------------------定义文件----------------------------
#include "PrimaryFactoy.h"
#include"PrimaryWolf.h"
#include"WildWolf.h"
WildWolf* PrimaryFactoy::createWildWolfMonster()
{
	return new PrimaryWolf;
}
WildBoar* PrimaryFactoy::createWildBoarMonster()
{
	
	return nullptr;
}

中级工厂

#pragma once
#include "MonsterFactory.h"
class MiddleFactory :
	public MonsterFactory
{
public:
	virtual WildWolf* createWildWolfMonster();
	virtual WildBoar* createWildBoarMonster();
};

#include "MiddleFactory.h"
#include"MiddleWolf.h"

WildWolf* MiddleFactory::createWildWolfMonster()
{
	return new MiddleWolf;
}
WildBoar* MiddleFactory::createWildBoarMonster()
{
	return nullptr;
}

高级工厂

#pragma once
#include "MonsterFactory.h"
class BossFactory :
	public MonsterFactory
{
public:
	virtual WildWolf* createWildWolfMonster();
	virtual WildBoar* createWildBoarMonster();

};

#include "BossFactory.h"
#include"BossWolf.h"


WildWolf* BossFactory::createWildWolfMonster()
{
	return new BossWolf;
}

WildBoar* BossFactory::createWildBoarMonster()
{
	return nullptr;
}

抽象产品类

#pragma once
class WildWolf
{
public:
	int m_HP;
	float m_attack;
	virtual int getHP() = 0;
	virtual float getAttack() = 0;
	
};

--------------------------------------------
#pragma once
class WildBoar
{
public:
	int m_HP;
	float m_attack;
	virtual void setHP(int hp) = 0;
	virtual void setAttack(float attack) = 0;
	


};

#pragma once
#include"WildWolf.h"
#include<iostream>
class PrimaryWolf
	:public WildWolf
{
public:
	
	virtual int getHP();
	virtual float getAttack();
	PrimaryWolf()
	{
		std::cout << "primaryWolf 创建" << std::endl;
		this->m_HP = 100;
		this->m_attack = -10;
	}
};

#include "PrimaryWolf.h"

int PrimaryWolf::getHP()
{
	return this->m_HP;
}

float PrimaryWolf::getAttack()
{
	return this->m_attack;
}

… …
基本上就是这样的

#include"PrimaryFactoy.h"
#include"MiddleFactory.h"
#include"BossFactory.h"
#include<iostream>

using namespace std;


int main(int argc, char **argv)
{
	MonsterFactory* m1 = new PrimaryFactoy;
	
	WildWolf* w1 = m1->createWildWolfMonster();
	cout << w1->getAttack() << endl;


	MonsterFactory* m2 = new MiddleFactory;
	WildWolf* w2 = m2->createWildWolfMonster();
	cout << w2->getAttack() << endl;

	MonsterFactory* m3 = new BossFactory;
	WildWolf* w3 = m3->createWildWolfMonster();
	cout << w3->getAttack() << endl;

	delete m1;
	delete m2;
	delete m3;

	delete w1;
	delete w2;
	delete w3;

	return 0;
}