欢迎来到 破晓的历程的 博客

⛺️不负时光，不负己✈️

---

简单工厂模

什么是简单工厂模式？

简单工厂模式是一种创新型的设计模式，当有一个基类和若干个派生类形成多态时，用于无须知道类对象是如何被创建的。当用户要创建对象时，直接向工厂申请即可。

如何实现简单工厂模式？

#include<iostream>
#include<string>
#include<functional>
#include<string>
using namespace std;
//基类
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;}
private:
};
//派生类
class AoDi :public Car
{
public:AoDi(string name):Car(name){}void show(){cout << "获取了一辆奥迪汽车: " <<_name<< endl;}
};
enum car_type
{bmw,aodi,
};
//这就是一个简单工厂类。通过该类，我们不需要知道类对象创建的具体细节。使用时调用即可。
class SimplayFactory
{
public:static Car* CreateCar(car_type ct, string name){switch (ct){case bmw:return new BMW(name);case aodi:return new AoDi(name);break;default:cerr << "输入错误" << endl ;break;}}
};
int main()
{Car* car1 = SimplayFactory::CreateCar(aodi, "x1");car1->show();
}

但是这样实现也有缺点：奥迪和宝马不可能在同一个工厂了被创建。然后这个工厂类也不符合开闭的原则「拓展开放，实现关闭」。基于这样的缺点，工厂方法应运而生。

工厂方法

工厂方法的实现如下：

//工厂方法   基类
class Factory
{
public:virtual Car* createCar(string name) = 0;
};
//不同工厂的具体实现  派生类
class BMWFactory :public Factory
{
public:Car* createCar(string name){return new BMW(name);}
};
//不同工厂的具体实现  派生类
class AoDiFactory
{Car* createCar(string name){return new  AoDi(name);}
};
int main()
{unique_ptr< Factory> bmwfaty(new BMWFactory());unique_ptr<Car>p1(bmwfaty->createCar("x6"));p1->show();}

当我们想增加奔驰的创建工厂的话，根本不需要动宝马和奥迪的工厂，我们只需要从基类中继承实现一个派生类，然后重写creator即可.
但是，一个工厂往往不止制造一产品，我们知道奥迪的车灯很出名，那么奥迪的工厂可能在造车的同时还会生产车灯，如果按照我们的工厂模式的话，就需要创建很多的类，这时就需要抽象工厂模式「在一个工厂内部，允许创建若干种产品」。

抽象工厂模式

代码如下，我们总体上还是使用刚刚的代码。

#include<iostream>
#include<string>
#include<functional>
#include<string>
using namespace std;
//基类
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;}
private:
};
//派生类
class AoDi :public Car
{
public:AoDi(string name):Car(name){}void show(){cout << "获取了一辆奥迪汽车: " <<_name<< endl;}
};
class Light
{
public:virtual void show(string name) = 0;
};
class BMWLight :public Light
{
public:void show(string name){cout << "BMW:" << name << endl;}
};
class AoDiLight :public Light
{
public:void show(string name){cout << "AoDi:" << name << endl;}
};
enum car_type
{bmw,aodi,
};
class Factory
{
public:virtual Car* createCar(string name) = 0;virtual Light* createCarLight() = 0;
};
class BMWFactory :public Factory
{
public:Car* createCar(string name){return new BMW(name);}Light* createCarLight(){return new BMWLight();}};
class AoDiFactory
{
public:Car* createCar(string name){return new  AoDi(name);}Light* createCarLight(){return new AoDiLight();}
};
int main()
{unique_ptr< Factory> bmwfaty(new BMWFactory());unique_ptr<Car>p1(bmwfaty->createCar("x6"));unique_ptr<Light>l1(bmwfaty->createCarLight());l1->show("a1");p1->show();}

总结

在历史进步的长河中，一种技术的出现，一定是为了解决前面技术带来的问题「弊端」。接下来，我们分析一下如上几种方案带来的问题：

简单工厂模式

优点
把对象的创建封装到一个接口函数里边，通过传入不同的标记，返回创建的对象。客户不用自己负责new对象。不用了解对象创建的详细过程。
缺点
提供创建对象实例的接口不闭合，不能对外修改关闭。

工厂方法

优点
Factory基类，提供了一个纯虚函数(创建产品)。定义派生类「具体产品的工厂」负责创建对应的产品，可以做到不同的产品，在不同的产品工厂里创建，能够对现有工厂以及产品的修改关闭。
缺点
实际上，很多产品都是有关联关系的，属于一个产品族，不应该放在 不同的工厂里创建，这样不符合实际的产品创建的创建逻辑，二是工厂类太多了，不好维护。

抽象工厂「Abstract Factory」

把有关联的，属于同一个产品系列的的所有产品的创建接口，放在同一个抽象工厂里边，派生类应负责常见该工厂内所有的产品。