前言

为什么要使用工厂模式

主要是对对象的创建进行了一个封装；
因此也属于创建型模式。

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

优点

1. 一个调用者想创建一个对象，只要知道其名称就可以了；
2. 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以；
3. 屏蔽产品的具体实现，调用者只关心产品的接口。

缺点

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

简单工厂（Simple Factory）

代码

首先是具体产品的实现和继承关系：

// 系列产品
class Car
{
public:
	Car(string name) :_name(name) {}
	virtual void show() = 0;
protected:
	string _name;
};
class Bmw:public Car
{
public:
	Bmw(string name) :Car(name) {}
	void show()
	{
		cout << "获取了一辆宝马汽车：" << _name << endl;
	}
};
class Audi :public Car
{
public:
	Audi(string name) :Car(name) {}
	void show()
	{
		cout << "获取了一辆奥迪汽车：" << _name << endl;
	}
};

接下来是简单工厂的实现：

// 产品枚举
enum Cartype
{
	BMW, AUDI
};
// 简单工厂类
class SimpleFactory
{
public:
	// 用户想要创建一个对象，只需要知道名称就可以了
	Car* createCar(Cartype ct)
	{
		switch (ct)
		{
		case BMW:
			return new Bmw("x6");
		case AUDI:
			return new Audi("a8");
		default:
			cerr << "传入参数错误：" << ct << endl;
		}
		return nullptr;
	}
};

应用

具体的使用规则如下：

int main()
{
	unique_ptr<SimpleFactory> fac(new SimpleFactory());
	unique_ptr<Car> p1(fac->createCar(BMW));
	unique_ptr<Car> p2(fac->createCar(AUDI));

	p1->show();
	p2->show();

	return 0;
}

需要注意的是：
为了更好地释放资源，这里使用了智能指针（需要加入头文件#include <memory>）；
也可以直接使用new的方法，代码如下：

	SimpleFactory* fac = new SimpleFactory();
	Car* p1 = fac->createCar(BMW);
	Car* p2 = fac->createCar(AUDI);

	p1->show();
	p2->show();

	delete fac;
	delete p1;
	delete p2;

使用普通指针（new）的时候就需要注意一定记得delete！

我们来看运行的结果：

不足

可以看到，简单工厂可以做到，让用户创建对象的时候只需要知道对象的名称（BMW、AUDI）就好，而不需要关心创建对象的细节（BMW是如何建造的、型号是什么等等细节）。

当然缺点也很明显：
每当我们想要扩展对象的时候（增加BENZ的对象）就需要在SimpleFactory类中添加代码，增加switch后面的case选项。这样一来，就需要修改源代码。灵活性非常的差！！！

那么，能不能做到添加对象的时候，不对现有代码进行修改呢？（也就是我们开发软件时候需要遵守的开-闭原则）

tips：
什么是开-闭原则呢？
对扩展开放、对修改关闭；
也就是说，我们可以添加代码，但是添加代码的时候不能够对现有的代码进行修改。
这样的代码才能算是好代码！！！

于是乎，便有了 工厂方法！

工厂方法（Factory Method）

工厂方法的思想就是定义一个Factory基类，基类中定义了一个纯虚函数（创建产品）；
之后定义派生类（具体产品的工厂）负责创建对应的产品。
可以做到不同的产品在不同的工厂里面创建，能够对现有工厂以及产品的修改关闭。

代码

同样的，具体产品的实现和继承同上：

// 系列产品
class Car
{
public:
	Car(string name) :_name(name) {}
	virtual void show() = 0;
protected:
	string _name;
};
class Bmw:public Car
{
public:
	Bmw(string name) :Car(name) {}
	void show()
	{
		cout << "获取了一辆宝马汽车：" << _name << endl;
	}
};
class Audi :public Car
{
public:
	Audi(string name) :Car(name) {}
	void show()
	{
		cout << "获取了一辆奥迪汽车：" << _name << endl;
	}
};

接下来是工厂方法的实现：

// 基类（包含纯虚函数，不能实例化对象）
class Factory
{
public:
	virtual Car* createCar(string name) = 0;
};
// 宝马汽车工厂，负责生产宝马汽车
class BmwFac: public Factory
{
public:
	Car* createCar(string name)
	{
		return new Bmw(name);
	}
};
// 奥迪汽车工厂，负责生产奥迪汽车
class AudiFac :public Factory
{
public:
	Car* createCar(string name)
	{
		return new Audi(name);
	}
};

应用

同样的，使用规则如下：

int main()
{
	unique_ptr<Factory> bmwfty(new BmwFac());
	unique_ptr<Factory> audifty(new AudiFac());
	unique_ptr<Car> p1 (bmwfty->createCar("X6"));
	unique_ptr<Car> p2 (audifty->createCar("A8"));
	
	p1->show();
	p2->show();

	return 0;
}

注意：
可以看到这一次的代码和之前简单工厂的不同：
简单工厂：unique_ptr<SimpleFactory> fac(new SimpleFactory())；
工厂方法：unique_ptr<Factory> bmwfty(new BmwFac())；
也就是说，工厂方法是用基类指针实例化派生类对象，这也是动态多态发生的条件。这样的话，就能够实现多态了！

之后的unique_ptr<Car> p1 (bmwfty->createCar("X6"))有没有更贴近生活呢？
我去买车，进到一家宝马4S店（对应具体的bmwfty对象），然后看上了心仪的车型bmw X6，然后告诉店员：“我想要一辆宝马X6”。之后办理完手续，就可以开心地提车了！

运行结果如下：

不足

工厂方法解决了简单工厂的问题（无法对修改关闭），但是它也有自己的局限：
试想一下，宝马工厂里面只是售卖成品汽车吗？
应该不是吧，作为一家成熟的工厂，除了汽车之外，还有一系列配套的零件、产品：比如说：轮胎、车灯、真皮豪华座椅等等。也就是说，跟汽车相关联的有一整个产品簇。

但是我们的宝马工厂BmwFac里面只有一个createCar方法，如果想要添加产品的话，就需要增加新的类。但是这些产品其实都应该在一个BmwFac工厂里面。这才是现实的逻辑，另外，工厂类太多，会不好维护。

于是乎，抽象工厂 应运而生。

抽象工厂（Abstract Factory）

抽象工厂的思想是：
把有关联关系的，属于一个产品簇的所有产品创建的接口函数，放在一个抽象工厂里面AbstractFactory，派生类（具体产品的工厂）应该负责创建该产品簇里面所有的产品。

代码

这一次，除了汽车产品外，我们再添加一个车灯产品，系列产品的实现和继承关系代码如下：

// 系列产品1：汽车
class Car
{
public:
	Car(string name) :_name(name) {}
	virtual void show() = 0;
protected:
	string _name;
};
class Bmw:public Car
{
public:
	Bmw(string name) :Car(name) {}
	void show()
	{
		cout << "获取了一辆宝马汽车：" << _name << endl;
	}
};
class Audi :public Car
{
public:
	Audi(string name) :Car(name) {}
	void show()
	{
		cout << "获取了一辆奥迪汽车：" << _name << endl;
	}
};
// 系列产品2：车灯
class Light
{
public:
	virtual void show() = 0;
};
class BmwLight : public Light
{
public:
	void show() { cout << "BMW light!" << endl; }
};
class AudiLight : public Light
{
public:
	void show() { cout << "Audi light!" << endl; }
};

接下来是抽象工厂的实现：

// 工厂方法 => 抽象工厂(对有一组关联关系的产品簇提供产品对象的统一创建)
class AbstractFactory
{
public:
	virtual Car* createCar(string name) = 0; // 工厂方法 创建汽车
	virtual Light* createCarLight() = 0; // 工厂方法 创建汽车关联的产品，车灯
};
// 宝马工厂
class BMWFactory : public AbstractFactory
{
public:
	Car* createCar(string name)
	{
		return new Bmw(name);
	}
	Light* createCarLight()
	{
		return new BmwLight();
	}
};
// 奥迪工厂
class AudiFactory : public AbstractFactory
{
public:
	Car* createCar(string name)
	{
		return new Audi(name);
	}
	Light* createCarLight()
	{
		return new AudiLight();
	}
};

应用

对于抽象工厂的使用如下：

int main()
{
	unique_ptr<AbstractFactory> bmwfty(new BMWFactory());
	unique_ptr<AbstractFactory> audifty(new AudiFactory());
	unique_ptr<Car> p1(bmwfty->createCar("X6"));
	unique_ptr<Car> p2(audifty->createCar("A8"));
	unique_ptr<Light> l1(bmwfty->createCarLight());
	unique_ptr<Light> l2(audifty->createCarLight());

	p1->show();
	l1->show();

	p2->show();
	l2->show();

	return 0;
}

运行结果如下：

参考资料

【1】工厂模式|菜鸟教程