05: 工厂方法模式

1. 案例: 加减乘除运算

2. 工厂方法模式结构

 - 抽象工厂(AbstractFactory): 所有生产具体产品的工厂类的基类，提供工厂类的公共方法

template <typename T>
class OperationFactory
{
public:
    virtual std::shared_ptr<Operation<T>> CreatOperation() = 0;
};

- 具体工厂(ConcreteFactory):生产具体的产品

template <typename T>
class OperationAddFactory :
    public OperationFactory<T>
{
public:
    std::shared_ptr<Operation<T>> CreatOperation() override;
};

template<typename T>
inline std::shared_ptr<Operation<T>> OperationAddFactory<T>::CreatOperation()
{
    return std::make_shared<OperationAdd<T>>();
}

template<class T>
class OperationSubFactory :
    public OperationFactory<T>
{
public:
    std::shared_ptr<Operation<T>> CreatOperation() override;
};

template<class T>
inline std::shared_ptr<Operation<T>> OperationSubFactory<T>::CreatOperation()
{
    return std::make_shared<OperationSub<T>>();
}

template <typename T>
class OperationMulFactory :
    public OperationFactory<T>
{
public:
    std::shared_ptr<Operation<T>> CreatOperation() override;
};

template<typename T>
inline std::shared_ptr<Operation<T>> OperationMulFactory<T>::CreatOperation()
{
    return std::make_shared<OperationMul<T>>();
}

template <typename T>
class OperationDivFactory :
    public OperationFactory<T>
{
public:
    std::shared_ptr<Operation<T>> CreatOperation() override;
};

template<typename T>
inline std::shared_ptr<Operation<T>> OperationDivFactory<T>::CreatOperation()
{
    return std::make_shared<OperationDiv<T>>();
}

- 抽象产品(AbstractProduct):所有产品的基类，提供产品类的公共方法

template <class T>
class Operation
{
public:
    virtual T GetResult() = 0;
    void SetNum(const T& Num1, const T& Num2);
protected:
    T m_Num1;
    T m_Num2;
};

template<class T>
inline void Operation<T>::SetNum(const T& Num1, const T& Num2)
{
    m_Num1 = Num1;
    m_Num2 = Num2;
}

- 具体产品(ConcreteProduct):具体产品类

template <class T>
class OperationAdd :
    public Operation<T>
{
public:
    T GetResult() override;
};

template<class T>
inline T OperationAdd<T>::GetResult()
{
    return Operation<T>::m_Num1 + Operation<T>::m_Num2;
}

template <typename T>
class OperationSub :
    public Operation<T>
{
public:
    T GetResult() override;
};

template<typename T>
inline T OperationSub<T>::GetResult()
{
    return Operation<T>::m_Num1 - Operation<T>::m_Num2;
}

template <typename T>
class OperationMul :public Operation<T>
{
public:
    T GetResult() override;
};

template<typename T>
inline T OperationMul<T>::GetResult()
{
    return Operation<T>::m_Num1 * Operation<T>::m_Num2;
}

template <typename T>
class OperationDiv :
    public Operation<T>
{
public:
    T GetResult() override;
};

template<typename T>
inline T OperationDiv<T>::GetResult()
{
    if (abs(Operation<T>::m_Num2) > 1e-6)
    {
        return Operation<T>::m_Num1 / Operation<T>::m_Num2;
    }
}

3. 用法

    auto spOperationAddFactory = std::make_shared<OperationAddFactory<float>>();
    auto spOperationAdd = spOperationAddFactory->CreatOperation();
    spOperationAdd->SetNum(2, 4);
    std::cout << spOperationAdd->GetResult() << std::endl;

    auto spOperationSubFactory = std::make_shared<OperationSubFactory<float>>();
    auto spOperationSub = spOperationSubFactory->CreatOperation();
    spOperationSub->SetNum(2, 4);
    std::cout << spOperationSub->GetResult() << std::endl;

    auto spOperationMulFactory = std::make_shared<OperationMulFactory<float>>();
    auto spOperationMul = spOperationMulFactory->CreatOperation();
    spOperationMul->SetNum(2, 4);
    std::cout << spOperationMul->GetResult() << std::endl;

    auto spOperationDivFactory = std::make_shared<OperationDivFactory<float>>();
    auto spOperationDiv = spOperationDivFactory->CreatOperation();
    spOperationDiv->SetNum(2, 4);
    std::cout << spOperationDiv->GetResult() << std::endl;