设计模式 -- 工厂方法模式 FactoryMethod

简单工厂模式违反了高内聚的原则，把所有的产品创建都集中在了一个具体工厂里面，为了克服这个缺点，工厂方法模式诞生！

工厂方法模式：定义一个创建对象的接口，让子类决定实例化哪个类，延迟实例化到子类。是简单工厂模式的升级版，有效的遵循了开放-封闭原则。

简单来说就是：

• 一个抽象产品类，可以派生出多个具体产品类。   
• 一个抽象工厂类，可以派生出多个具体工厂类。   
• 每个具体工厂类只能创建一个具体产品类的实例。

给出模式结构图：

计算器例子升级版：

#include <iostream>
#include <cstdlib>
 
using namespace std;
 
//产品抽象类
class Operation
{
public:
    virtual double getResult() const = 0;
 
    double getNumA() const {
        return numA;
    }
 
    void setNumA(double numA) {
        this->numA = numA;
    }
 
    double getNumB() const {
        return numB;
    }
 
    void setNumB(double numB) {
        this->numB = numB;
    }
 
private:
    double numA;
    double numB;
};
 
//具体产品类Add
class OperationAdd : public Operation
{
public:
    double getResult() const
    {
        return getNumA() + getNumB();
    }
};
 
class OperationSub : public Operation
{
public:
    double getResult() const
    {
        return getNumA() - getNumB();
    }
};
 
class OperationMul : public Operation
{
public:
    double getResult() const
    {
        return getNumA() * getNumB();
    }
};
 
class OperationDiv : public Operation
{
public:
    double getResult() const
    {
        if(getNumB() == 0)
        {
            cout << "除数不能为0" << endl;
            exit(1);
        }
        return getNumA() / getNumB();
    }
};
 
//新增加的具体产品类Pow
class OperationPow : public Operation
{
public:
    double getResult() const
    {
        double result = 1;
        for(int i=0; i<getNumB(); i++)
        {
            result = result * getNumA();
        }
        return result;
    }
};
 
//工厂接口类:核心
class IFactory
{
public:
    virtual Operation* createOperation() const = 0;
};
 
//具体工厂类Add
class AddFactory : public IFactory
{
public:
    Operation* createOperation() const
    {
        return new OperationAdd();
    }
};
 
class SubFactory : public IFactory
{
public:
    Operation* createOperation() const
    {
        return new OperationSub();
    }
};
 
class MulFactory : public IFactory
{
public:
    Operation* createOperation() const
    {
        return new OperationMul();
    }
};
 
class DivFactory : public IFactory
{
public:
    Operation* createOperation() const
    {
        return new OperationDiv();
    }
};
 
//新增具体Pow工厂类
class PowFactory : public IFactory
{
public:
    Operation* createOperation() const
    {
        return new OperationPow();
    }
};
 
int main()
{
    IFactory* factory = new PowFactory();   //创建并初始化工厂接口
    Operation* operation = factory->createOperation();   //利用工厂接口创建具体产品类，并交给抽象产品类管理
    operation->setNumA(4);
    operation->setNumB(3);
    cout << operation->getResult() << endl;
    return 0;
}