C++工厂方法之对象创建型模式详解

#include <iostream>
using namespace std;
// 怪物父类
class Monster
{
public:
	// 构造函数
	Monster(int life, int magic, int attack) : m_life(life), m_magic(magic), m_attack(attack) {}
	virtual ~Monster() {} // 父类的析构函数应该为虚函数
protected: // 可能被子类访问的成员，所以用protected修饰
	int m_life; // 生命值
	int m_magic; // 魔法值
	int m_attack; // 攻击力
};
// 亡灵类怪物
class M_Undead : public Monster
{
public:
	// 构造函数
	M_Undead(int life, int magic, int attack) : Monster(life, magic, attack)
	{
		cout << "一个亡灵类怪物来到了这个世界" << endl;
	}
	// 其他代码略
};
// 元素类怪物
class M_Element : public Monster
{
public:
	// 构造函数
	M_Element(int life, int magic, int attack) : Monster(life, magic, attack)
	{
		cout << "一个元素类怪物来到了这个世界" << endl;
	}
	// 其他代码略
};
// 机械类怪物
class M_Mechanic : public Monster
{
public:
	// 构造函数
	M_Mechanic(int life, int magic, int attack) : Monster(life, magic, attack)
	{
		cout << "一个机械类怪物来到了这个世界" << endl;
	}
	// 其他代码略
};
// 所有工厂类的父类
class M_ParFactory
{
public:
	virtual Monster* createMonster() = 0; // 具体实现在子类中进行
	virtual ~M_ParFactory() {} // 父类的析构函数应该为虚函数
};
// M_Undead怪物类型的工厂，生产M_Undead类型怪物
class M_UndeadFactory : public M_ParFactory
{
public:
	virtual Monster* createMonster()
	{
		Monster *ptmp = new M_Undead(300, 50, 80); // 创建亡灵类怪物
		//这里可以增加一些其他业务代码
		return ptmp;
	}
};
// M_Element怪物类型的工厂，生产M_Element类型怪物
class M_ElementFactory : public M_ParFactory
{
public:
	virtual Monster* createMonster()
	{
		return new M_Element(200, 80, 100); // 创建元素类怪物
	}
};
// M_Mechanic怪物类型的工厂，生产M_Mechanic类型怪物
class M_MechanicFactory : public M_ParFactory
{
public:
	virtual Monster* createMonster()
	{
		return new M_Mechanic(400, 0, 110); // 创建机械类怪物
	}
};
// 全局函数：用于创建怪物对象
// 注意：形参的类型是工厂父类类型的指针，返回类型是怪物父类类型的指针
Monster* Gbl_CreateMonster(M_ParFactory* factory)
{
	return factory->createMonster();
	// createMonster虚函数扮演了多态new的行为，factory指向的具体怪物工厂类不同，创建的怪物对象也不同
}
int main()
{
	M_ParFactory* p_ud_fy = new M_UndeadFactory(); // 多态工厂，注意指针类型
	Monster* pM1 = Gbl_CreateMonster(p_ud_fy); // 产生了一只亡灵类怪物，也是多态，注意返回类型
	// 当然，这里也可以直接写成 Monster *pM1 = p_ud_fy->createMonster();
	M_ParFactory* p_elm_fy = new M_ElementFactory();
	Monster *pM2 = Gbl_CreateMonster(p_elm_fy); // 产生了一只元素类怪物
	M_ParFactory* p_mec_fy = new M_MechanicFactory();
	Monster* pM3 = Gbl_CreateMonster(p_mec_fy); // 产生了一只机械类怪物
	// 释放工厂
	delete p_ud_fy;
	delete p_elm_fy;
	delete p_mec_fy;
	// 释放怪物
	delete pM1;
	delete pM2;
	delete pM3;
	return 0;
}

#include <iostream>
using namespace std;
// 怪物父类
class Monster
{
public:
	// 构造函数
	Monster(int life, int magic, int attack) : m_life(life), m_magic(magic), m_attack(attack) {}
	virtual ~Monster() {} // 父类的析构函数应该为虚函数
protected: // 可能被子类访问的成员，所以用protected修饰
	int m_life; // 生命值
	int m_magic; // 魔法值
	int m_attack; // 攻击力
};
// 亡灵类怪物
class M_Undead : public Monster
{
public:
	// 构造函数
	M_Undead(int life, int magic, int attack) : Monster(life, magic, attack)
	{
		cout << "一个亡灵类怪物来到了这个世界" << endl;
	}
	// 其他代码略
};
// 元素类怪物
class M_Element : public Monster
{
public:
	// 构造函数
	M_Element(int life, int magic, int attack) : Monster(life, magic, attack)
	{
		cout << "一个元素类怪物来到了这个世界" << endl;
	}
	// 其他代码略
};
// 机械类怪物
class M_Mechanic : public Monster
{
public:
	// 构造函数
	M_Mechanic(int life, int magic, int attack) : Monster(life, magic, attack)
	{
		cout << "一个机械类怪物来到了这个世界" << endl;
	}
	// 其他代码略
};
// 所有工厂类的父类
class M_ParFactory
{
public:
	virtual Monster* createMonster() = 0; // 具体实现在子类中进行
	virtual ~M_ParFactory() {} // 父类的析构函数应该为虚函数
};
template <typename T>
class M_ChildFactory :public M_ParFactory
{
public:
	virtual Monster* createMonster()
	{
		return new T(300, 50, 80); //如果需要不同的值则可以通过createMonster的形参将值传递进来
	}
};
int main()
{
	M_ChildFactory<M_Undead> myFactory;
	Monster* pM10 = myFactory.createMonster();
	// 释放资源
	delete pM10;
	getchar();
	return 0;
}