C++设计模式——工厂模式(Factory Pattern)

Posted 2021-04-25 幼儿园的学霸

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++设计模式——工厂模式(Factory Pattern)相关的知识，希望对你有一定的参考价值。

C++设计模式——工厂模式(Factory Pattern)

主要特点:产品创建过程在工厂类中完成，当增加新产品时，需要修改工厂类。使用简单工厂模式，我们只需要知道具体的产品型号就可以创建一个产品。
缺点：工厂类集中了所有产品类的创建逻辑，如果产品量较大，会使得工厂类变的非常臃肿。

（以手机的生产讲解该模式）

#include <bits/stdc++.h>

using std::cout;
using std::endl;

//
//简单工厂模式
//


typedef enum PhoneTypeTag {
    MI_PHONE,
    IPHONE_PHONE,
    HUAWEI_PHONE
} PhoneType;


//产品抽象基类 AbstractProduct
class Phone {
    //添加虚析构函数！
public:
    virtual void type() = 0;//代表共有属性
};

//
//具体的产品类
//

class MiPhone : public Phone {
public:
    void type() override {
        cout << "I'm XiaoMi Phone !" << endl;
    }
};

class IPhone : public Phone {
public:
    void type() override {
        cout << "I'm IPhone !" << endl;
    }
};

class HuaweiPhone : public Phone {
public:
    void type() override {
        cout << "I'm Huawei Phone !" << endl;
    }
};

//工厂类 手机代工厂
class PhoneFactory {
public:
    //根据产品信息创建具体的产品类示例，返回一个抽象产品类
    std::shared_ptr<Phone> MakePhone(const PhoneType type) {
        switch (type) {
            case PhoneType::MI_PHONE:
                return std::make_shared<MiPhone>();
            case PhoneType::IPHONE_PHONE:
                return std::make_shared<IPhone>();
            case PhoneType::HUAWEI_PHONE:
                return std::make_shared<HuaweiPhone>();
            default:
                return nullptr;
        }
    }

};

int main() {
    PhoneFactory phoneFactory;
    std::shared_ptr<Phone> m_phone = nullptr;

    m_phone = phoneFactory.MakePhone(PhoneType::MI_PHONE);
    m_phone->type();

    m_phone = phoneFactory.MakePhone(PhoneType::IPHONE_PHONE);
    m_phone->type();

    m_phone = phoneFactory.MakePhone(PhoneType::HUAWEI_PHONE);
    m_phone->type();

    //动态绑定
    //m_phone = std::make_shared<MiPhone>();
    //m_phone->type();

    return 0;
}

代码运行输出结果如下：

I'm XiaoMi Phone !
I'm IPhone !
I'm Huawei Phone !

看完上面的代码是否有一种疑惑：采用动态绑定,直接new一下不就实现同样的效果了吗。
直接new确实很方便，但是在大型软件开发中这样很危险，用专业术语来说是违反了依赖倒置原则：

高层模块不应该依赖于低层模块，二者都应该依赖于抽象；抽象不应该依赖于细节，细节应该依赖于抽象

通俗来讲，引入的依赖并不可靠，它一般是第三方库或是其他开发人员实现的代码，在不确定的某一天，里面的代码会被修改甚至是删除。这时候你的代码变的很脆，不知不觉中就崩了。但现实中又不可能不引入其他依赖，所以大家就约定最小依赖引入：依赖提供者将隐藏对象的属性和实现细节，仅对外公开接口(抽象),这就是OOP三大特性之一:封装(另外2个是继承和多态)。因此，也可以说，工厂模式是为了实现封装特性

回看一下上面的代码，我们只调用了工厂类的一个接口CreateProduct就实现了派生方法的动态绑定，这样具体"手机产品"(MiPhone,IPhone,HuaWeiPhone)的修改(如修改了类名)就不影响现有代码了。假设某天"手机工厂"(PhoneFactory)开发者觉得MiPhone子类有了性能更好的实现，他只需在简单工厂里面换一个新的派生类(如SuperMiPhone)即可，而具体的调用者的代码不需要做任何改动。

工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。

客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。

工厂模式的最大优点就是屏蔽产品的具体实现，调用者只关心产品的接口。当然，它也有自己的问题，产品种类可能有成千上万，如果都是依靠同一个工厂生产，那么必然会使得工厂代码及其庞大。这就有了工厂方法的设计实现。

工厂方法模式

其实这才是正宗的工厂模式，简单工厂模式只是一个简单的对创建过程封装。

和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂。

在代码实现上，工厂方法模式在简单工厂模式的基础上增加对工厂的基类抽象，不同的产品创建采用不同的工厂创建（从工厂的抽象基类派生），这样创建不同的产品过程就由不同的工厂分工解决：FactoryA专心负责生产ProductA，FactoryB专心负责生产ProductB，FactoryA和FactoryB之间没有关系；如果到了后期，如果需要生产ProductC时，我们则可以创建一个FactoryC工厂类，该类专心负责生产ProductC类产品。

该模式相对于简单工厂模式的优势在于：便于后期产品种类的扩展。如果需要增加新的产品类，只需要扩展一个相应的工厂类即可。
缺点：产品类数据较多时，需要实现大量的工厂类，这无疑增加了代码量。

#include <bits/stdc++.h>

using std::cout;
using std::endl;

//
//工厂方法模式
//

//产品抽象基类 AbstractProduct
class Phone {
    //添加虚析构函数！
public:
    virtual void type() = 0;//代表共有属性
};

//
//具体的产品类
//

class MiPhone : public Phone {
public:
    void type() override {
        cout << "I'm XiaoMi Phone !" << endl;
    }
};

class IPhone : public Phone {
public:
    void type() override {
        cout << "I'm IPhone !" << endl;
    }
};

class HuaweiPhone : public Phone {
public:
    void type() override {
        cout << "I'm Huawei Phone !" << endl;
    }
};

//抽象工厂类，提供一个创建接口
class PhoneFactory {
public:
    //提供创建产品实例的接口，返回抽象产品类
    virtual std::shared_ptr<Phone> MakePhone() = 0;
};

//具体的创建工厂类，使用抽象工厂类提供的接口，各具体的工厂去创建具体的产品实例
class MiPhoneFactory : public PhoneFactory {
public:
    std::shared_ptr<Phone> MakePhone() override {
        return std::make_shared<MiPhone>();
    }
};

class IPhoneFactory : public PhoneFactory {
public:
    std::shared_ptr<Phone> MakePhone() override {
        return std::make_shared<IPhone>();
    }
};

class HuaWeiPhoneFactory : public PhoneFactory {
public:
    std::shared_ptr<Phone> MakePhone() override {
        return std::make_shared<HuaweiPhone>();
    }
};


int main() {
    std::shared_ptr<Phone> m_pPhone = nullptr;

    m_pPhone = MiPhoneFactory().MakePhone();
    m_pPhone->type();

    m_pPhone = IPhoneFactory().MakePhone();
    m_pPhone->type();

    m_pPhone = HuaWeiPhoneFactory().MakePhone();
    m_pPhone->type();

    return 0;
}

工厂方法减轻了工厂类的负担，新增一种“手机”只需添加一个特定的“手机工厂”即可，这就符合了开放闭合原则：

对扩展是开放的；对修改是关闭的

这里提一下，开放闭合原则并不是说接口一成不变，它要求的是增量变化——只增加新方法，不改动旧方法。

抽象工厂模式

工厂方法自然比简单工厂更加灵活，但当业务有所变更时，比如需要添加“手机”的周边产品——“电脑”呢？这时候我们就需要一个更复杂的模式——抽象工厂

抽象工厂是一个产品簇的概念，一个工厂可以生产多种业务相关的产品。我们在工厂方法的基础上扩充一下代码：定义一个抽象工厂接口AbstractFactory，通过不同的方法生产出一个“抽象”产品簇（Phone和PC）。回过头来再看工厂方法，事实上它就是抽象工厂最简单的一种场景设计——只生成一种产品。

抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建，当然前提是子工厂支持生产该产品。否则继承的这个接口可以什么也不干。

#include <bits/stdc++.h>

using std::cout;
using std::endl;

//
//抽象工厂模式
//

//手机产品抽象基类 AbstractProduct
class Phone {
    //添加虚析构函数！
public:
    virtual void type() = 0;//代表共有属性
};

//
//具体的手机产品类
//

class MiPhone : public Phone {
public:
    void type() override {
        cout << "I'm XiaoMi Phone !" << endl;
    }
};

class IPhone : public Phone {
public:
    void type() override {
        cout << "I'm IPhone !" << endl;
    }
};

class HuaweiPhone : public Phone {
public:
    void type() override {
        cout << "I'm Huawei Phone !" << endl;
    }
};


//PC产品抽象基类 AbstractProduct
class PC {
    //添加虚析构函数！
public:
    virtual void type() = 0;//代表共有属性
};

//
//具体的手机产品类
//

class MiPC : public PC {
public:
    void type() override {
        cout << "I'm XiaoMi PC !" << endl;
    }
};

class MACPC : public PC {
public:
    void type() override {
        cout << "I'm MAC PC !" << endl;
    }
};

class HuaweiPC : public PC {
public:
    void type() override {
        cout << "I'm Huawei PC !" << endl;
    }
};



//抽象工厂类，提供一个创建接口,其中增加PC产品接口
class AbstractFactory {
public:
    //提供创建产品实例的接口，返回抽象产品类
    virtual std::shared_ptr<Phone> MakePhone() = 0;
    virtual std::shared_ptr<PC> MakePC() = 0;
};



//具体的创建工厂类，使用抽象工厂类提供的接口，各具体的工厂去创建具体的产品实例
class MiFactory : public AbstractFactory {
public:
    std::shared_ptr<Phone> MakePhone() override {
        return std::make_shared<MiPhone>();
    }

    std::shared_ptr<PC> MakePC() override{
        return std::make_shared<MiPC>();
    }
};

class IPhoneFactory : public AbstractFactory {
public:
    std::shared_ptr<Phone> MakePhone() override {
        return std::make_shared<IPhone>();
    }
    std::shared_ptr<PC> MakePC() override{
        return std::make_shared<MACPC>();
    }
};

class HuaWeiFactory : public AbstractFactory {
public:
    std::shared_ptr<Phone> MakePhone() override {
        return std::make_shared<HuaweiPhone>();
    }
    std::shared_ptr<PC> MakePC() override{
        return std::make_shared<HuaweiPC>();
    }
};

//另外一个代工厂，生产MiPhone和MAC
class OdmFactory : public AbstractFactory {
public:
    std::shared_ptr<Phone> MakePhone() override {
        return std::make_shared<MiPhone>();
    }
    std::shared_ptr<PC> MakePC() override{
        return std::make_shared<MACPC>();
    }
};



int main()
{
    std::shared_ptr<Phone> m_pPhone = nullptr;
    std::shared_ptr<PC> m_pPC = nullptr;

    MiFactory miFactory;
    IPhoneFactory iPhoneFactory;
    HuaWeiFactory huaWeiFactory;
    OdmFactory odmFactory;

    m_pPhone = miFactory.MakePhone();
    m_pPC = miFactory.MakePC();
    m_pPhone->type();
    m_pPC->type();

    m_pPhone = iPhoneFactory.MakePhone();
    m_pPC = iPhoneFactory.MakePC();
    m_pPhone->type();
    m_pPC->type();

    m_pPhone = huaWeiFactory.MakePhone();
    m_pPC = huaWeiFactory.MakePC();
    m_pPhone->type();
    m_pPC->type();

    m_pPhone = odmFactory.MakePhone();
    m_pPC = odmFactory.MakePC();
    m_pPhone->type();
    m_pPC->type();


    return 0;
}

代码输出如下：

I'm XiaoMi Phone !
I'm XiaoMi PC !
I'm IPhone !
I'm MAC PC !
I'm Huawei Phone !
I'm Huawei PC !
I'm XiaoMi Phone !
I'm MAC PC !

在抽象工厂模式中，增加新的产品族很方便(如可以将IPhone和HuaWeiPC作为一个产品系列，只用增加一个工厂即可)，但是增加新的产品等级结构很麻烦(如，增加键盘作为新的产品，那么不仅需要增加新的产品类，同时各个工厂也需要进行对应的调整，将键盘这一产品增加进去)。

总结

工厂模式最直观的理解是，减少new创建对象的方式，用接口的方式来返回一个对象，而new创建的方式被封装了

简单工厂：调用者只需使用单例工厂就可获取同一范畴的所有产品

工厂方法：调用者并不知道它在运行时会获取何种产品，只知道某个特定的工厂能生成出满足需求的产品

抽象工厂：调用者可以在运行时从特定的工厂中获得所有信息相关的产品簇(可以对产品进行组合)

工厂方法模式和抽象工厂模式区别：区别在于产品，如果产品单一，最合适用工厂模式，但是如果有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。再通俗深化理解下：工厂模式针对的是一个产品等级结构，抽象工厂模式针对的是面向多个产品等级结构的。

是否可以这样理解呢：工厂方法模式生产一种产品，抽象工厂模式生产一系列产品，构成的是一个生态

参考资料

1.几种常见的设计模式（含C++代码） https://blog.csdn.net/u010993820/article/details/80968933
2.C++ 常用设计模式（学习笔记） https://www.cnblogs.com/chengjundu/p/8473564.html
3.设计模式之工厂模式（factory pattern）https://www.cnblogs.com/yssjun/p/11102162.html

图注:幼儿园的学霸

以上是关于C++设计模式——工厂模式(Factory Pattern)的主要内容，如果未能解决你的问题，请参考以下文章

(C++设计模式) —— 常见设计模式学习笔记 - Factory模式（工厂）

Headfirst设计模式的C++实现——简单工厂模式(Simple Factory)之二

设计模式-工厂方法（Factory Method）

Headfirst设计模式的C++实现——抽象工厂(Abstract Factory)

C++设计模式之-工厂模式的总结

C++设计模式——工厂模式(Factory Pattern)

C++设计模式——工厂模式(Factory Pattern)

目录

简单工厂模式

工厂方法模式

抽象工厂模式

总结

参考资料