C++之工廠設計模式

簡單來說，工廠設計模式包含：簡單工廠，工廠方法和抽象工廠三種。

簡單工廠

适用場合：

• 在程式中，需要建立的對象很多，導緻對象的構造很複雜時，需要使用簡單工廠模式；
• 由于對象的建立過程是我們不需要去關心的，而我們注重的是對象的實際操作，是以，我們需要分離對象的建立和操作兩部分，友善後期的程式擴充和維護。

UML：

c++代碼示例：

#ifndef DESIGN_PATTERNS_SIMPLEFACTORY_H
#define DESIGN_PATTERNS_SIMPLEFACTORY_H

#include <iostream>
#include <string>
#include <memory>

enum class PhoneType {
    xiaomi = 0,
    huawei,
    apple
};

//手機基類
class PhoneBase {
public:
    using Ptr = std::shared_ptr<PhoneBase>;

    virtual void create() {}
};

//小米手機
class XiaomiPhone : public PhoneBase {
public:
    using Ptr = std::shared_ptr<XiaomiPhone>;

    void create() override {
        std::cout << "Xiao mi phone" << std::endl;
    }
};

//華為手機
class HuaweiPhone : public PhoneBase {
public:
    using Ptr = std::shared_ptr<HuaweiPhone>;

    void create() override {
        std::cout << "Huawei phone" << std::endl;
    }
};

//蘋果手機
class ApplePhone : public PhoneBase {
public:
    using Ptr = std::shared_ptr<ApplePhone>;

    void create() override {
        std::cout << "Apple phone" << std::endl;
    }
};

class PhoneFactory {
public:
    static PhoneBase::Ptr createPhone(PhoneType type) {
        PhoneBase::Ptr phone = nullptr;
        switch (type) {
            case PhoneType::xiaomi:
                phone = std::make_shared<XiaomiPhone>();
                break;
            case PhoneType::huawei:
                phone = std::make_shared<HuaweiPhone>();
                break;
            case PhoneType::apple:
                phone = std::make_shared<ApplePhone>();
            default:
                break;
        }
        return phone;
    }
};

#endif //DESIGN_PATTERNS_SIMPLEFACTORY_H           

工廠方法

适用場合：

工廠方法模式的意義是定義一個建立産品對象的工廠接口，将實際建立工作推遲到子類當中。核心工廠類不再負責産品的建立，這樣核心工廠類成為一個抽象工廠角色，僅負責具體工廠子類必須實作的接口，這樣進一步抽象化的好處是使得工廠方法模式可以使系統在不修改具體工廠角色的情況下引進新的産品。

UML：

c++代碼示例：

#ifndef DESIGN_PATTERNS_FACTORY_H
#define DESIGN_PATTERNS_FACTORY_H

#include <iostream>
#include <memory>

//汽車基類
class CarBase {
public:
    using Ptr = std::shared_ptr<CarBase>;

    virtual void create() {}
};

//比亞迪汽車
class BYDCar : public CarBase {
public:
    using Ptr = std::shared_ptr<BYDCar>;

    void create() override {
        std::cout << "BYD car" << std::endl;
    }
};

//長城汽車
class ChangChengCar : public CarBase {
public:
    using Ptr = std::shared_ptr<ChangChengCar>;

    void create() override {
        std::cout << "ChangCheng car" << std::endl;
    }
};

//汽車工廠基類
class CarFactoryBase {
public:
    using Ptr = std::shared_ptr<CarFactoryBase>;

    virtual CarBase::Ptr createCar() { return nullptr; }
};

//比亞迪汽車工廠
class BYDCarFactory : public CarFactoryBase {
public:
    using Ptr = std::shared_ptr<BYDCarFactory>;

    CarBase::Ptr createCar() override {
        return std::make_shared<BYDCar>();
    }
};

//長城汽車工廠
class ChangChengFactory : public CarFactoryBase {
public:
    using Ptr = std::shared_ptr<ChangChengFactory>;

    CarBase::Ptr createCar() override {
        return std::make_shared<ChangChengCar>();
    }
};

#endif //DESIGN_PATTERNS_FACTORY_H           

抽象工廠

适用場合:

工廠方法模式适用于産品種類結構單一的場合，為一類産品提供建立的接口；

而抽象工廠方法适用于産品種類結構多的場合，主要用于建立一組（有多個種類）相關的産品，為它們提供建立的接口。

UML：

c++代碼示例：

#ifndef DESIGN_PATTERNS_ABSTRACTFACTORY_H
#define DESIGN_PATTERNS_ABSTRACTFACTORY_H

#include <iostream>
#include <memory>

//燃油汽車
class FuelProduct {
public:
    using Ptr = std::shared_ptr<FuelProduct>;

    virtual ~FuelProduct() {}

    virtual void create() = 0;
};

//電動汽車
class MotorProduct {
public:
    using Ptr = std::shared_ptr<MotorProduct>;

    virtual ~MotorProduct() {}

    virtual void create() = 0;
};

//比亞迪燃油汽車
class BYDTangProduct : public FuelProduct {
public:
    using Ptr = std::shared_ptr<BYDTangProduct>;

    ~BYDTangProduct() override {}

    void create() override {
        std::cout << "BYD Tang fuel Car" << std::endl;
    }
};

//比亞迪電動汽車
class BYDQingProduct : public MotorProduct {
public:
    using Ptr = std::shared_ptr<BYDQingProduct>;

    ~BYDQingProduct() override {}

    void create() override {
        std::cout << "BYD Qing Moto Car" << std::endl;
    }
};

//特斯拉ModelY
class TeslaModelYProduct : public MotorProduct {
public:
    using Ptr = std::shared_ptr<TeslaModelYProduct>;

    ~TeslaModelYProduct() override {}

    void create() override {
        std::cout << "Tesla Model Y Moto Car" << std::endl;
    }
};

//抽象汽車工廠
class AbstractCarFactory {
public:
    using Ptr = std::shared_ptr<AbstractCarFactory>;

    virtual ~AbstractCarFactory() {}

    //生産燃油車
    virtual FuelProduct::Ptr createFuelCar() = 0;

    //生産電動車
    virtual MotorProduct::Ptr createMotoCar() = 0;
};

//特斯拉汽車工廠
class TeslaProductFactory : public AbstractCarFactory {
public:
    using Ptr = std::shared_ptr<TeslaProductFactory>;

    ~TeslaProductFactory() override {}

    FuelProduct::Ptr createFuelCar() override {
        return nullptr;    //因為特斯拉不生産燃油車
    }

    MotorProduct::Ptr createMotoCar() override {
        return std::make_shared<TeslaModelYProduct>();
    }
};

//比亞迪汽車工廠
class BYDProductFactory : public AbstractCarFactory {
public:
    using Ptr = std::shared_ptr<BYDProductFactory>;

    FuelProduct::Ptr createFuelCar() override {
        return std::make_shared<BYDTangProduct>();
    }

    MotorProduct::Ptr createMotoCar() override {
        return std::make_shared<BYDQingProduct>();
    }
};

#endif //DESIGN_PATTERNS_ABSTRACTFACTORY_H