工厂方法模式

工厂方法模式定义

工厂方法模式，定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

工厂方法模式结构图

图 01 工厂模式结构图

工厂方法模式套用代码

#include "iostream"
using namespace std;

// 这边只有生产运算的工厂类，而没有运算的具体实现类，建议查看底部实例的代码，很完整
// 如果需要查看运算的具体实现类请查看简单工厂模式
class IFactory
{
public:
    virtual Operation* CreateOperation() = 0;
};

class AddFactory : public IFactory
{
public:
    virtual Operation* CreateOperation()
    {
        return new OperationAdd()
    }
};

class SubFactory : public IFactory
{
    virtual Operation* CreateOperation()
    {
        return new OperationSub()
    }
};

class MulFactory : public IFactory
{
    virtual Operation* CreateOperation()
    {
        return new OperationMul()
    }
};

class DivFactory : public IFactory
{
    virtual Operation* CreateOperation()
    {
        return new OperationDiv()
    }
};

void main()
{
    IFactory* operFactory = new AddFactory();
    Operation oper = operFactory.CreateOperation();
    
    oper.NumberA = 1;
    oper.NumberB = 2;
    double result = oper.GetResult();
}

简单工厂模式与工厂方法模式的比较

简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。但是假设我们现在要添加运算X²，如果使简单工厂模式，我们需要在switch()中添加case语句，这样造成了对原有的类进行修改，违反了“开放-封闭”，相对的使用工厂模式则不会。

为了方便对比附简单工厂模式的类图如下：

 

图 02 简单工厂模式类图

工厂方法模式实例

下图是关于简单运算使用工厂方法模式类图

 

图 03 工厂模式实例类图

工厂方法模式实例实现代码 

#include "iostream"
using namespace std;

// 父类
class COperation
{
private:
    double numberA;
    double numberB;
public:
    COperation()
    {
        numberA = 0;
        numberB = 0;
    }
    inline double GetNumberA() const
    {
        return numberA;
    }

    inline double GetNumberB() const
    {
        return numberB;
    }
    
    inline void SetNumberB(double numberB)
    {
        this->numberB = numberB;
    }

    inline void SetNumberA(double numberA)
    {
        this->numberA = numberA;
    }
    
    // 计算结果
    virtual double GetResult()
    {
        return 0.0;
    }
};

// 加
class COperationAdd : public COperation
{
public:
    virtual double GetResult()
    {
        return GetNumberA() + GetNumberB();
    }
};

// 减
class COperationSub : public COperation
{
public:
    double GetResult()
    {
        return this->GetNumberA() - this->GetNumberB();
    }
};

// 乘
class COperationMul : public COperation
{
public:
    double GetResult()
    {
        return this->GetNumberA() * this->GetNumberB();
    }
};

// 除
class COperationDiv : public COperation
{
public:
    double GetResult()
    {
        return this->GetNumberA() / this->GetNumberB();
    }
};

// 工厂父类
class CIFactory
{
public:
    // 纯虚函数
    virtual COperation* CreateOperation() = 0;
};

// 生产加法对象的工厂
class CAddFactory : public CIFactory
{
public:
    virtual COperation* CreateOperation()
    {
        return new COperationAdd();
    }
};

// 生产减法对象的工厂
class CSubFactory : public CIFactory
{
public:
    virtual COperation* CreateOperation()
    {
        return new COperationSub();
    }
};

// 生产乘法对象的工厂
class CMulFactory : public CIFactory
{
public:
    virtual COperation* CreateOperation()
    {
        return new COperationMul();
    }
};

// 生产除法对象的工厂
class CDivFactory : public CIFactory
{
public:
    virtual COperation* CreateOperation()
    {
        return new COperationDiv();
    }
};

void main()
{
    CIFactory* factory = new CDivFactory();
    COperation* operation = factory->CreateOperation();
    operation->SetNumberA(17.0);
    operation->SetNumberB(2.0);
    cout << operation->GetResult() << endl;
}

2014-11-26  22:49:23