【设计模式】工厂模式

设计模式共23种，总共分为三大类：创建型模式，结构型模式，行为性模式

工厂模式属于创建型模式，其聚焦于如何组织类去实例化一个对象，实际上就是在原本直接的new的基础上进行一个封装，达到可以方便随时变更，扩展，和其他类交互的功能

简单工厂

简单工厂顾名思义，十分简单，基本思想就是创建一个工厂类用来管理某一类对象的实例化，用户只需要实例化一个工厂对象，并传入一个字符串或枚举来确定自己需要的对象，工厂就能自动构造出一个所需的对象，而创建这个对象的所有操作都会集中在工厂内进行，后期需要修改时也无需到处去替换，只需在工厂内修改。

代码定义了一个Unit基类，三种继承其的角色和一个用于创建三种角色的Factory类

从代码也很明显可以看出简单工厂的缺点，就是每次增加一个类，都需要去修改工厂内部的函数，不符合开闭原则，当类过多时也难以修改。当然如果类不多，那么简单工厂就足够使用了，毕竟正如其名，简单工厂

#include <iostream>
using namespace std;namespace SimpleFactory
{
class Unit
{
public:virtual void Call() = 0;
};class Warrior : public Unit
{
public:virtual void Call() override{cout << "I am Warrior!" << endl;}
};class Archer : public Unit
{
public:virtual void Call() override{cout << "I am Archer!" << endl;}
};class Wizard : public Unit
{
public:virtual void Call() override{cout << "I am Wizard!" << endl;}
};namespace EUnit
{enum Type{Warrior,Archer,Wizard};
}//简单工厂(显然不符合开闭原则)
class UnitFactory
{
public:Unit* CreateUnit(EUnit::Type unit){switch(unit){case EUnit::Warrior:return new Warrior();case EUnit::Archer:return new Archer();case EUnit::Wizard:return new Wizard();}return nullptr;}
};
}int main()
{//简单工厂{using namespace SimpleFactory;UnitFactory factory;Unit* warrior = factory.CreateUnit(EUnit::Warrior);Unit* archer = factory.CreateUnit(EUnit::Archer);Unit* wizard = factory.CreateUnit(EUnit::Wizard);warrior->Call();archer->Call();wizard->Call();}
}

工厂模式

工厂模式在简单工厂的基础上，遵循了开闭原则，即对修改关闭，对扩展开放，将增加支持的类的操作从修改函数变成了继承并写新的子类

即工厂模式提供了一个工厂基类，需要一种产品时就创建对应的工厂类

下述代码和简单工厂最大的不同就是创建了一个工厂类的接口，并实现了三种工厂对应三种单位，使用时创建对应的单位来创建所需的对象。

之所以这样看着感觉毫无意义徒增复杂度，是因为这只是最基础的代码框架，在每个子类和父类，和继承链条上的每一处都可以插入其他的函数来扩展创建时的功能，最简单的，如果你需要一个计数器来记录创建的对象数量，那么直接在工厂的父类中创建一个静态变量，或者创建一个专门的计数类，并在工厂中引用这个计数类，在创建时累加。这些都可以轻松做到

#include <iostream>
using namespace std;namespace FactoryPattern
{//通过定义接口进行使用
class IUnit
{
public:virtual void Call() = 0;virtual ~IUnit() {};
};class IFactory
{
public:virtual IUnit* Create() = 0;
};class Warrior : public IUnit
{
public:virtual void Call() override{cout << "I am Warrior!" << endl;}
};class Archer : public IUnit
{
public:virtual void Call() override{cout << "I am Archer!" << endl;}
};class Wizard : public IUnit
{
public:virtual void Call() override{cout << "I am Wizard!" << endl;}
};class WarriorFactory : public IFactory
{
public:virtual IUnit* Create() override{return new Warrior();}
};class ArcherFactory : public IFactory
{
public:virtual IUnit* Create() override{return new Archer();}
};class WizardFactory : public IFactory
{
public:virtual IUnit* Create() override{return new Wizard();}
};}int main()
{//工厂模式{using namespace FactoryPattern;IFactory* factorys[3];factorys[0] = new WarriorFactory();factorys[1] = new ArcherFactory();factorys[2] = new WizardFactory();for(int i = 0; i < 3; i++){IUnit* unit = factorys[i]->Create();unit->Call();delete unit;}	}
}

抽象工厂模式

上述工厂类，在使用过程中，因为每个产品类都需要一个对应的工厂类，这样在后期会导致工厂类的数量膨胀，其结果是同样也不好维护，最好的方式是将有类似性质的类组成一组，放在一个工厂中，这样可以十分有效的减少工厂类的数量，同时对于上层用户而言，也无需创建特别多的工厂来创建所需的对象

下面的代码解释：一个接口IEqiupable代表可穿戴的接口，然后由Weapon和Armor两个大类分别继承

接下来再细分两个大类，剑与弓，重甲与轻甲

创建IFactory工厂类接口，工厂能够创建Weapon和Armor两种物品

MeleeFactory近战工厂生产的是剑和重甲

RemoteFactory远程工厂生产的是弓和轻甲

#include <iostream>
using namespace std;namespace AbstractFactory
{class IEqiupable{public:virtual void Show() = 0;virtual ~IEqiupable() {};};class Weapon : public IEqiupable{public:virtual void Show() override{cout << "武器：" << GetName() << "\t";};protected:virtual string GetName() = 0;};class Sword : public Weapon{virtual string GetName() override{return "剑";}};class Bow : public Weapon{virtual string GetName() override{return "弓";}};class Armor : public IEqiupable{public:virtual void Show() override{cout << "防具：" << GetName();};protected:virtual string GetName() = 0;};class LightArmor : public Armor{virtual string GetName() override{return "轻甲";}};class HeavyArmor : public Armor{virtual string GetName() override{return "重甲";}};class IFactory{public:virtual Weapon* CreateWeapon() = 0;virtual Armor* CreateArmor() = 0;};class MeleeFactory : public IFactory{public:virtual Weapon* CreateWeapon() override{return new Sword();}virtual Armor* CreateArmor() override{return new HeavyArmor();}};class RemoteFactory : public IFactory{public:virtual Weapon* CreateWeapon() override{return new Bow();}virtual Armor* CreateArmor() override{return new LightArmor();}};
}int main()
{//抽象工厂模式{using namespace AbstractFactory;MeleeFactory meleeFacotory;Weapon* weapon = meleeFacotory.CreateWeapon();Armor* armor = meleeFacotory.CreateArmor();weapon->Show();armor->Show();cout << endl;delete weapon;delete armor;RemoteFactory remoteFactory;weapon = remoteFactory.CreateWeapon();armor = remoteFactory.CreateArmor();weapon->Show();armor->Show();}
}