工厂模式（C++编码）

一、工厂模式概念及分类

工厂模式概念：用一个简单的类来创建实例的过程便称为工厂，用工厂方式代替外部new操作的一种设计模式称为工厂模式。这是一种创建型模式，它提供了一个创建对象的最佳方式。在工厂模式中，我们创建对象时不会对上层暴露创建逻辑，而是通过使用一个共同结构来指向新创建的对象。

工厂模式分类：简单工厂模式、工厂方法模式、抽象工厂模式。

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

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

解决方法：让其子类实现工厂接口，返回的是一个抽象的产品。

使用前提：1、编码时不能预见需要创建哪种类的实例（不同的条件下发创建不同实例）；2、系统不应依赖于产品类实例如何被创建、组合和表达的细节。

关键代码：子类执行创建过程。

优点：1、使代码结构清晰，有效地封装变化，提高拓展性；2、屏蔽产品的具体实现，调用者只关心产品的接口；3、降低耦合度。

二、各类工厂模式讲解及实现

1、简单工厂模式

（1）概述

简单工厂模式时属于创建型模式，又叫做静态工厂方法模式，简单工厂模式实现由一个工厂对象决定创建出来指定产品类的实例。

（2）特点

简单工厂模式由一个工厂类根据传入的参数，动态决定应该创建哪一种产品类实例。简单工厂模式需要在工厂类中作出判断，在创建产品的时候指定响应产品创造。

（3）类图

（4）例子

假设有个工厂能生产出 A、B 两种产品，当客户需要产品的时候明确告知工厂生产哪类产品，工厂需要接收顾客提供的类别信息，当新增产品的时候，工厂内部去添加新产品的生产方式。

（5）应用说明

一个工厂，多个产品，产品需要有一个虚基类，通过接收类别参数生产具体产品，利用基类指针指向此对象。

（6）编码

#include <iostream>
​
enum ProductType
{
    PRODUCT_A,
    PRODUCT_B
};
​
// 产品基类
class Product
{
public:
    virtual void Show() = 0;
};
​
// 产品 A
class ProductA : public Product
{
public:
    void Show()
    {
        std::cout << "Product A." << std::endl;
    }
};
​
// 产品 B
class ProductB : public Product
{
public:
    void Show()
    {
        std::cout << "Porduct B." << std::endl;
    }
};
​
// 工厂
class Factory
{
public:
    Product* Create(int type)
    {
        switch(type)
        {
            case PRODUCT_A : return new ProductA; break;
            case PRODUCT_B : return new ProductB; break;
​
            default : break;
        }
    }
};
​
int main()
{
    Factory *factory = new Factory();
​
    factory->Create(PRODUCT_A)->Show();
    factory->Create(PRODUCT_B)->Show();
​
    return 0;
}

（7）缺点

工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了，违背开闭原则。当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利。

2、工厂方法模式

（1）概述

多个工厂，多个产品，每个产品对应一个工厂，此时工厂和产品都通过虚基类方式构建。

（2）特点

定义一个用于创建对象的接口，让子类决定实例化哪一个类。当增加一个新产品时，同时增加一个新工厂。增加新工厂属于扩展，不会修改以前工厂类和产品类的任何代码。可以看过多个独立的简单工厂模式构成了工厂方法模式。工厂方法让类的实例化推迟到子类中进行。

（3）类图

（4）例子

假设现在有 A、B 两种产品，则开两个工厂，工厂 A 负责生产产品 A，工厂 B 负责生产产品 B，客户只知道创建产品的工厂名，而不知道具体的产品名，工厂不需要再接收客户的产品类别，而只去生产产品。

（5）应用说明

把简单工厂模式中的工厂类抽象出一个结构，这个接口只有一个创建抽象产品的工厂方法，工厂方法模式解决了简单工厂模式中出现的缺点。

（6）编码

#include <iostream>
​
// 产品基类
class Product
{
public:
    virtual void Show() = 0;
};
​
// 工厂基类
class Factory
{
public:
    virtual Product* Create() = 0;
};
​
// 产品 A
class ProductA : public Product
{
public:
    void Show()
    {
        std::cout << "Product A." << std::endl;
    }
};
​
// 产品 B
class ProductB : public Product
{
public:
    void Show()
    {
        std::cout << "Porduct B." << std::endl;
    }
};
​
// 工厂 A
class FactoryA : public Factory
{
public:
    Product* Create()
    {
        return new ProductA;
    }
};
​
// 工厂 B
class FactoryB : public Factory
{
public:
    Product* Create()
    {
        return new ProductB;
    }
};
​
int main()
{
    FactoryA *factoryA = new FactoryA();
    FactoryB *factoryB = new FactoryB();
​
    factoryA->Create()->Show();
    factoryB->Create()->Show();
​
    return 0;
}

（7）适用场景

工厂方法模式和简单工厂模式虽然都是通过工厂来创建对象，他们之间最大的不同是——工厂方法模式在设计上完全完全符合开闭原则。适用场景：1、一个类不知道它所需要的对象的类（在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类）；2、一个类通过其子类来指定创建哪个对象（在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展）；3、将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。

（8）具体应用

• 日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。

• 数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。

• 设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。

（9）缺点

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

3、抽象工厂模式

（1）概述

工厂方法模式通过引入工厂等级结构，解决了简单工厂模式中工厂类职责太重的问题，但由于工厂方法模式中的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，势必会增加系统的开销。此时，我们可以考虑将一些相关的产品组成一个产品族（位于不同产品等级结构中功能相关联的产品组成的家族），由同一个工厂来统一生产，这就是抽象工厂模式的基本思想。

（2）特点

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

（3）类图

（4）例子

假如 A 产品中有 A1 和 A2 两种型号的产品，B 产品中有 B1 和 B2 两种型号的产品，这个时候使用抽象工厂模式，还是开设两家工厂，工厂等级为 1 则负责生产 A1 、B1 型号产品，工厂等级为 2 则负责生产 A2、B2 型号的产品。这样减少了工厂类和产品类在项目中的数量，并完成针对多个产品等级结构的抽象。

（5）编码

#include <iostream>
 
// Product A
class ProductA
{
public:
    virtual void Show() = 0;
};
 
class ProductA1 : public ProductA
{
public:
    void Show()
    {
        std::cout << "Product A1." << std::endl ;
    }
};
 
class ProductA2 : public ProductA
{
public:
    void Show()
    {
        std::cout << "Product A2." << std::endl ;
    }
};
 
// Product B
class ProductB
{
public:
    virtual void Show() = 0;
};
 
class ProductB1 : public ProductB
{
public:
    void Show()
    {
        std::cout << "Product B1." << std::endl ;
    }
};
 
class ProductB2 : public ProductB
{
public:
    void Show()
    {
        std::cout << "Product B2." << std::endl ;
    }
};
 
// Factory
class Factory
{
public:
    virtual ProductA* CreateProductA() = 0;
    virtual ProductB* CreateProductB() = 0;
};
 
class Factory1 : public Factory
{
public:
    ProductA* CreateProductA()
    {
        return new ProductA1();
    }
 
    ProductB* CreateProductB()
    {
        return new ProductB1();
    }
};
 
class Factory2 : public Factory
{
    ProductA* CreateProductA()
    {
        return new ProductA2();
    }
 
    ProductB* CreateProductB()
    {
        return new ProductB2();
    }
};
 
int main()
{
    Factory  *factoryObj1  = new Factory1();
    ProductA *productObjA1 = factoryObj1->CreateProductA();
    ProductB *productObjB1 = factoryObj1->CreateProductB();
 
    productObjA1->Show();
    productObjB1->Show();
 
    Factory  *factoryObj2  = new Factory2();
    ProductA *productObjA2 = factoryObj2->CreateProductA();
    ProductB *productObjB2 = factoryObj2->CreateProductB();
 
    productObjA2->Show();
    productObjB2->Show();
 
    return 0;
}

（6）适用场景

• 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。

• 系统中有多于一个的产品族，而每次只使用其中某一产品族。

• 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。

• 系统结构稳定，不会频繁的增加对象。

（7）开闭原则的倾斜性

在抽象工厂模式中，增加新的产品族很方便，但是增加新的产品等级结构很麻烦，抽象工厂模式的这种性质称为开闭原则的倾斜性。开闭原则要求系统对扩展开放，对修改封闭，通过扩展达到增强其功能的目的，对于涉及到多个产品族与多个产品等级结构的系统，其功能增强包括两方面：1、增加产品族——对于增加新的产品族，工厂方法模式很好的支持了开闭原则，对于新增加的产品族，只需要对应增加一个新的具体工厂即可，对已有代码无须做任何修改。2、增加新的产品等级结构——对于增加新的产品等级结构，需要修改所有的工厂角色，包括抽象工厂类，在所有的工厂类中都需要增加生产新产品的方法，违背了开闭原则。

正因为抽象工厂模式存在开闭原则的倾斜性，它以一种倾斜的方式来满足开闭原则，为增加新产品族提供方便，但不能为增加新产品结构提供这样的方便，因此要求设计人员在设计之初就能够全面考虑，不会在设计完成之后向系统中增加新的产品等级结构，也不会删除已有的产品等级结构，否则将会导致系统出现较大的修改，为后续维护工作带来诸多麻烦。

（8）优点

易于交换产品系列，由于具体工厂类在一个应用中只需要在初始化的时候出现一次，这样就使得改变一个应用的具体工厂变得非常容易，只需要改变具体工厂即可使用不同的产品配置。让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂实现分离，不会出现在客户代码中。

（9）缺点

增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”。

三、工厂模式的退化过程

当抽象工厂模式中每一个具体工厂类只创建一个产品对象，也就是只存在一个产品等级结构时，抽象工厂模式退化成工厂方法模式；当工厂方法模式中抽象工厂与具体工厂合并，提供一个统一的工厂来创建产品对象，并将创建对象的工厂方法设计为静态方法时，工厂方法模式退化成简单工厂模式。

四、Reference

1、C++工厂模式分析和总结（阿里云开发者社区）：https://developer.aliyun.com/article/761946

2、工厂模式——这一篇就够了（InfoQ写作平台）：https://xie.infoq.cn/article/88c926822394aa1c80847dd2a

3、23种设计模式全面解析（C语言中文网）：http://c.biancheng.net/design_pattern/