C++设计模式（五）—工厂方法模式

工厂方法模式

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

本文使用书中雷锋工厂事例，代码使用C++语言描述，代码存在的不足或问题有望各位指出。

（1）前面我们已经针对计算器实例有简单工厂实现，下面我们使用工厂方法来实现

  //此方法将numA 和numB声明为protected类型

#include <iostream>
#include <exception>
using namespace std;
class Operation
{
public:
    Operation() = default;
    virtual ~Operation() = default;
    Operation(double numA, double numB)
    {
        this->numA = numA;
        this->numB = numB;

    }
    virtual double getResult()   //虚函数
    {
        double result = 0;
        return result;
    }

protected:
    double numA = 0;
    double numB = 0;
};


class OperationAdd : public Operation
{
public:
    OperationAdd(double numA, double numB)
    {
        this->numA = numA;
        this->numB = numB;
    }
    double getResult() override
    {
        double result = 0;
        result = numA + numB;
        return result;

    }
};

class OperationSub : public Operation
{
public:
    OperationSub(double numA, double numB)
    {
        this->numA = numA;
        this->numB = numB;
    }
    double getResult() override
    {
        double result = 0;
        result = numA - numB;
        return result;
    }

};

class OperationMul : public Operation
{
public:
    OperationMul(double numA, double numB)
    {
        this->numA = numA;
        this->numB = numB;
    }
    double getResult() override
    {
        double result = 0;
        result = numA * numB;
        return result;
    }

};

class OperationDiv : public Operation
{
public:
    OperationDiv(double numA, double numB)
    {
        this->numA = numA;
        this->numB = numB;
    }
    double getResult() override
    {
        double result = 0;
        if (numB == 0)
            throw ("分母不为零");
        result = numA /numB;
        return result;
    }

};

class IFactory
{
public:
    IFactory(){}
    virtual ~IFactory(){}
    virtual Operation *CreateOperation( double numA, double numB )=0;
};

class AddFactory : public IFactory
{
public:
    Operation *CreateOperation(double numA, double numB) override
    {
        return new OperationAdd(numA, numB);
    }
};

class SubFactory : public IFactory
{
public:
    Operation *CreateOperation(double numA, double numB) override
    {
        return new OperationSub(numA, numB);
    }

};

class MulFactory : public IFactory
{
public:
    Operation *CreateOperation(double numA, double numB) override
    {
        return new OperationMul(numA, numB);
    }

};

class DivFactory : public IFactory
{
public:
    Operation *CreateOperation(double numA, double numB) override
    {
        return new OperationDiv(numA, numB);
    }
};


int main()
{
    try{
        IFactory *operFactory = new DivFactory();
        Operation *oper = operFactory->CreateOperation(5,8);
        double result = oper->getResult();
        cout<<"结果是："<<result <<endl;
        delete operFactory;
        delete oper;
    }catch(char *ex)
    {
        cout <<ex <<endl;
    }
}

1、简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。但是问题也在这里，如果要加一个求M数的N次方的功能，我们一定需要给运算工厂类的方法里面加‘case’的分支条件的，修改原有的类。这就违背了开放-

2、工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断问题还是存在的，也就是说，工厂方法把简单内部逻辑判断移到了客户端代码来进行。你想要加功能，本来是改工厂类的，而现在是修改客户端！

（2）雷锋工厂实现

//雷锋工厂
#include <iostream>
using namespace std;

class LeiFeng
{
public:
    void Sweep()
    {
        cout<< "扫地" <<endl;
    }

    void Wash()
    {
        cout<< "洗衣" <<endl;
    }
    void buyRice()
    {
        cout<< "买米" <<endl;
    }

};

class UnderGraduate : public LeiFeng
{

};

class Volunteer : public LeiFeng
{

};

class IFactory
{
public:
    IFactory (){}
    virtual ~IFactory(){}
    virtual LeiFeng* createLeiFeng()=0;

};

class UnderGraduateFactory :public IFactory
{
public:
    LeiFeng* createLeiFeng() override
    {
        return new UnderGraduate();
    }

};

class VolunteerFactory : public IFactory
{
public:
    LeiFeng* createLeiFeng() override
    {
        return new Volunteer();
    }

};

int main()
{


    IFactory *iFactory =new UnderGraduateFactory();
    LeiFeng *student = iFactory->createLeiFeng();
    student->Sweep();
    student->Wash();
    student->buyRice();
    delete iFactory;
    delete student;
    return 0;

}

1、工厂方法克服了简单工厂违背开放-封闭原则的缺点，又保持了封装对象创建过程的优点。

2、简单工厂模式和工厂方法模式都是集中封装了对象的创建，使得要更换对象时，不需要做大的改动就可以实现，降低了客户程序与产品对象的耦合。工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。但是缺点是由于每加一个产品，就需要加一个产品工厂的类，增加了额外的开发量。