一、基本概念

【1. 概念：】

工厂模式为了生成产品，在C++中就是为了生成对象，优点是：

• 不需要关注对象的生成过程。
• 简化名称，便以使用。

【2. 分类：】

• 简单工厂模式： 不属于23种设计模式；所有产品一个工厂设计，适用于固定生产线流程。
• 工厂方法模式： 属于23种设计模式；多个工厂，一个工厂一个产品，适用于规模不固定。
• 抽象工厂模式： 属于23种设计模式；多个工厂，一个工厂生产关联性强的配套产品，适用于关联性强的产品。

二、简单工厂模式

（一）基本概念：

【1. 含义：】

同一工厂产多个产品，如就一个工厂，即生产苹果，也生产香蕉，如下图所示：

【2. 优点：】

1. 对象的生成都是在工厂中，在使用点不需要关系怎么产生对象。
2. 简化了名称；传入1，2，就可以生成苹果，香蕉，和派生类类名无关了。

【3. 缺点：】

违背了开放-封闭原则。开放：新版本设计时可以使用旧版本的代码。封闭：不能修改旧版本的代码。如新加一个水果种类，就需要修改工厂代码，增加一条生产线来生产新增水果，这就违背了开-闭原则。

【4. 适用场景】

简单工厂适用于规模固定，不容易发生产品变动的工厂

（二）示例：水果工厂

我们设计一个水果工厂，主要 类设计如下：

根据类设计图我们写出对应的 代码：

//1. 普通工厂模式，一个工厂，多条生产线class Fruit//抽象水果类
{
public:Fruit(std::string m):name(m){}virtual void oparator()=0;
protected:std::string name;
};
class Apple:public Fruit
{
public:Apple(std::string m):Fruit(m){};void oparator(){std::cout<<"eat apple"<<std::endl;}
};
class Banana:public Fruit
{
public:Banana(std::string m):Fruit(m){};void oparator(){std::cout<<" eat banana"<<std::endl;}
};
class Factory//建立水果工厂
{
public:Factory(){std::cout<<"水果工厂建立完成"<<std::endl;}Fruit* create(int flag){switch(flag){case 1:std::cout<<"苹果生产完成"<<std::endl;return new Apple("apple");//生产苹果break;case 2:std::cout<<"香蕉生产完成"<<std::endl;return new Banana("banana");//生产香蕉break;default:return NULL;break;}}
};
int main()
{Factory F;//建立工厂Fruit* pf=F.create(1);//生产苹果Fruit* pf1=F.create(2);//生产香蕉
}

运行代码：

我们先建立了一个工厂，传入序号，就可以生产出对应的水果。不需要传入复杂的类名，不需要关系具体的过程，这就是过程模式的优点。

三、工厂方法模式

（一）基本概念：

【1. 含义：】

所有的产品不是在一个工厂中产生，一个工厂只能产生一种产品。如下图所示：

【2. 优点：】

1. 通过工厂名称简化产品名称，1号工厂产苹果，2号工厂产香蕉。
2. 添加新产品，建立新工厂即可，没有违背开放-封闭原则。

【3. 缺点：】

一个工厂生产一个产品，浪费资源。

【4. 适用场景】

工厂方法模式适用于：规模不固定，产品易发生变化的场景。

（二）示例：水果工厂

我们设计一个水果工厂，可以生成多种水果，类关系如下图所示：

根据类图，我们写出具体 代码：

//2.工厂模式，一个工厂生产一种产品，多个工厂
//两个工厂，一个生产苹果，一个生产香蕉
class Fruit//抽象水果类
{
public:Fruit(std::string m):name(m){}virtual void oparator()=0;
protected:std::string name;
};
class Apple:public Fruit
{
public:Apple(std::string m):Fruit(m){};void oparator(){std::cout<<"apple"<<std::endl;}
};
class Banana:public Fruit
{
public:Banana(std::string m):Fruit(m){};void oparator(){std::cout<<"banana"<<std::endl;}
};
class Factory//工厂抽象类
{
public:Factory(std::string name):fname(name){}virtual Fruit* create()=0;//纯虚函数
protected:std::string fname;
};
class Fa:public Factory//苹果工厂
{
public:Fa(std::string name):Factory(name){std::cout<<"苹果工厂建立完成"<<std::endl;}Fruit* create()//生产苹果{std::cout<<"苹果生产完成"<<std::endl;return new Apple("apple");//生产苹果}
};
class Fb:public Factory//香蕉工厂
{
public:Fb(std::string name):Factory(name){std::cout<<"香蕉工厂建立完成"<<std::endl;}Fruit* create()//生产香蕉{std::cout<<"香蕉生产完成"<<std::endl;return new Banana("banana");//生产香蕉}
};
int main()
{Fb fb("1");//建立香蕉工厂Fruit* f=fb.create();//生产香蕉Fa fa("2");//建立苹果工厂Fruit* f1=fa.create();//生产苹果
}

运行代码：

传入序号建立对应水果的工厂，工厂生产水果。利用序号简化工厂名称，不需要传入苹果，香蕉等水果名称；也不需要关心生产过程。

三、抽象工厂模式

（一）基本概念：

【1. 含义：】

假如现在需要A1+B1=AB1，A2+B2=AB2，如果使用工厂方法模式进行生产，那么就会有一个工厂生产A1，一个生产B1，一个生产A2，一个生产B2，这样就有可能出现A1+B2组装的情况。

为了解决这种问题，产生了抽象工厂模式：一个工厂生成多个产品，产品之间有很强的相关性，如下图所示：

【2. 优点：】

• 一个工厂产生多个产品，产品之间有关联性。
• 抽象工厂模式结合了简单工厂模式和工厂方法模式，一个工厂生产具有强相关性的一组或多组产品。

【3. 缺点：】

逻辑设计复杂

【4. 适用场景】

适用于创建关联性强的产品，即创建关联性强的对象。

（二）示例：

生产套装A1+B1，A2+B2，那么需要两个工厂，一个工厂生产A1，B1；一个生产A2，B2。那么类图如下：

根据类图，写出代码：

//3.抽象工厂模式，一个工厂生产配套的产品如A1+B1，假如现在需要生产A1+B1,A2+B2产品，那么需要两个工厂
class A//生产A类产品
{
public:A(std::string n):name(n){}
protected:std::string name;
};
class A1 :public A//生产A1产品
{
public:A1(std::string n):A(n){}
};
class A2 :public A//生产A2产品
{
public:A2(std::string n):A(n){}
};
class B//生产B类产品
{
public:B(std::string n):name(n){}
protected:std::string name;
};
class B1 :public B//生产B2产品
{
public:B1(std::string n):B(n){}
};
class B2:public B//生产A2产品
{
public:B2(std::string n):B(n){}
};
class Factory//建立工厂抽象类
{
public:Factory(std::string n):name(n){}virtual A* createA()=0;//生产A类产品virtual B* createB()=0;//生产B类产品
protected:std::string name;
};
class F1 :public Factory//生产A1+B1产品
{
public:F1(std::string n):Factory(n){std::cout<<"生产A1+B1产品工厂建立完成"<<std::endl;}A* createA()//生产A1产品{std::cout<<"A1生产完成"<<std::endl;return new A1("A1");}B* createB()//生产B1产品{std::cout<<"B1生产完成"<<std::endl;return new B1("B1");}
};
class F2 :public Factory//生产A2+B2产品
{
public:F2(std::string n):Factory(n){std::cout<<"生产A2+B2产品工厂建立完成"<<std::endl;}A* createA()//生产A1产品{std::cout<<"A1生产完成"<<std::endl;return new A2("A2");}B* createB()//生产B1产品{std::cout<<"B2生产完成"<<std::endl;return new B2("B2");}
};
int main()
{Factory* f=new F1("A1+B1");A* pa1=f->createA();B* pb1=f->createB();Factory* f2=new F2("A2+B2");A* pa2=f2->createA();B* pb2=f2->createB();
}

运行代码：

提供建立对应序号的工厂，就可以产生配套产品；简化了名称，不需要了解过程。

加油哦！🥠。