C++工厂模式（简单工厂工厂方法抽象工厂）
Posted Redamanc
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++工厂模式（简单工厂工厂方法抽象工厂）相关的知识，希望对你有一定的参考价值。
工厂模式
前言
为什么要使用工厂模式
主要是对对象的创建进行了一个封装；
因此也属于创建型模式。
意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
主要解决：主要解决接口选择的问题。
优点
- 一个调用者想创建一个对象，只要知道其名称就可以了；
- 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以；
- 屏蔽产品的具体实现，调用者只关心产品的接口。
缺点
每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。
简单工厂（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】工厂模式|菜鸟教程
以上是关于C++工厂模式（简单工厂工厂方法抽象工厂）的主要内容，如果未能解决你的问题，请参考以下文章