设计模式(1)-使用简单工厂优化代码

首先看一段程序，目的是完成一个计算器的计算，

面向过程的写法

?

#include "stdafx.h"

#include <string>

#include <iostream>

 

using namespace std;

 

int main(int argc, char* argv[])

{

    int strNumA,strNumB;

    int strOperator;

    cout<<"请输入数字A：\n";

    cin>>strNumA;

    cout<<"请选择运算符号（1,+,2,-,3,*,4,/）：\n";

    cin>>strOperator;

    cout<<"请输入数字B：\n";

    cin>>strNumB;

 

    int strResult;

    switch(strOperator)

    {

        case OPERATOR_ADD:

            strResult = strNumA + strNumB;

            break;

        case OPERATOR_MINUS:

            strResult = strNumA - strNumB;

            break;

        case OPERATOR_MUTHL:

            strResult = strNumA * strNumB;

            break;

        case OPERATOR_DIV:

            if(strNumB!=0)

                strResult = strNumA / strNumB;

            else

                cout<<"您输入的有误，除数不能为0！"<<endl;

            break;

        default:

            cout<<"输入有错误！"<<endl;

            break;

    }

    cout<<"得到的结果是："<<strResult;

    return 0;

}

这样出来的程序每次都需要修改，比如我要添加一个取平方根的操作，需要修改程序，如果在增加，还是继续修改。

面向对象和面向过程的对比就不用多说了吧，借用书上的一句话

通过继承封装和多态把程序的耦合度降低，使用设计模式使程序更灵活更加容易复用。

第一步 剥离业务，现在程序都是混在一起的，将业务剥离出来

创建类Operaton

?

class Operaton

{

public:

    int getResult(int strNumA,int operFlag,int strNumB)

    {

        int result=0;

        switch(operFlag)

        {

            case OPERATOR_ADD:

                result = strNumA + strNumB;

                break;

            case OPERATOR_MINUS:

                result = strNumA - strNumB;

                break;

            case OPERATOR_MUTHL:

                result = strNumA * strNumB;

                break;

            case OPERATOR_DIV:

                if(strNumB!=0)

                    result = strNumA / strNumB;

                else

                    cout<<"您输入的有误，除数不能为0！"<<endl;

                break;

            default:

                cout<<"输入有错误！"<<endl;

                break;

        }

        return result;

    }

};

修改main函数

?

int main(int argc, char* argv[])

{

    int strNumA,strNumB;

    int strOperator;

    cout<<"请输入数字A：\n";

    cin>>strNumA;

    cout<<"请选择运算符号（1,+,2,-,3,*,4,/）：\n";

    cin>>strOperator;

    cout<<"请输入数字B：\n";

    cin>>strNumB;

 

    int strResult = 0;

    Operaton *op = new Operaton;

    strResult = op->getResult(strNumA,strOperator,strNumB);

    cout<<"得到的结果是："<<strResult;

    return 0;

}

这样实现了业务逻辑的分离，但是还是没解决刚才的问题，如果再添加操作或业务还需要再修改业务类文件。

第二步 使用简单工厂

工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。

 看一下类图的描述

从而得到的几个文件Operaton.cpp，Operaton.h，OperatonAdd.cpp，OperatonAdd.h,OperatonSub.cpp，OperatonSub.h，OperatonMul.cpp，OperatonMul.h，OperatonDiv.cpp，OperatonDiv.h

Operaton.h

?

<p>class Operaton<br>{</p><p>public:<br> Operaton();<br> virtual ~Operaton();<br> int numA;<br> int numB;</p><p> virtual int getResult() = 0;</p><p>};</p>

 Operaton.cpp

?

<p>#include "stdafx.h"<br>#include "Operaton.h"</p><p><br>Operaton::Operaton(){</p><p>}</p><p>Operaton::~Operaton(){</p><p>}</p>

OperatonAdd.h

?

#include "Operaton.h"

 

class OperatonAdd : public Operaton

{

 

public:

    OperatonAdd();

    virtual ~OperatonAdd();

 

    int getResult();

 

};

 OperatonAdd.cpp

?

#include "stdafx.h"

#include "OperatonAdd.h"

 

 

OperatonAdd::OperatonAdd(){

 

}

 

OperatonAdd::~OperatonAdd(){

 

}

 

int OperatonAdd::getResult(){

    return numB + numA;

}

 OperatonSub.h

?

#include "Operaton.h"

 

class OperatonSub : public Operaton

{

 

public:

    OperatonSub();

    virtual ~OperatonSub();

 

    virtual int getResult();

 

};

OperatonSub.cpp

?

#include "stdafx.h"

#include "OperatonSub.h"

 

OperatonSub::OperatonSub(){

 

}

 

OperatonSub::~OperatonSub(){

 

}

 

int OperatonSub::getResult(){

    return numA * numB;

}

 OperatonMul.h

?

#include "Operaton.h"

 

class OperatonMul : public Operaton

{

 

public:

    OperatonMul();

    virtual ~OperatonMul();

 

    virtual int getResult();

 

};

OperatonMul.cpp

?

#include "stdafx.h"

#include "OperatonMul.h"

 

OperatonMul::OperatonMul(){

 

}

 

OperatonMul::~OperatonMul(){

 

}

 

int OperatonMul::getResult(){

    return numA - numB;

}

 OperatonDiv.h

?

#include "Operaton.h"

#include <iostream>

 

using namespace std;

 

class OperatonDiv : public Operaton

{

 

public:

    OperatonDiv();

    virtual ~OperatonDiv();

 

    virtual int getResult();

 

};

OperatonDiv.cpp

?

#include "stdafx.h"

#include "OperatonDiv.h"

 

 

OperatonDiv::OperatonDiv(){

 

}

 

OperatonDiv::~OperatonDiv(){

 

}

 

int OperatonDiv::getResult(){

    int result;

    if(numB!=0)

        result = numA / numB;

    else

        cout<<"您输入的有误，除数不能为0！"<<endl;

    return result;

}

OperatonFactory.h

?

class OperatonFactory

{

 

public:

    OperatonFactory();

    virtual ~OperatonFactory();

 

    Operaton* create(int operFlag);

 

};

OperatonFactory.cpp

?

#include "stdafx.h"

#include "Operaton.h"

#include "OperatonAdd.h"

#include "OperatonDiv.h"

#include "OperatonMul.h"

#include "OperatonSub.h"

#include "OperatonFactory.h"

 

 

OperatonFactory::OperatonFactory(){

 

}

 

OperatonFactory::~OperatonFactory(){

 

}

 

Operaton* OperatonFactory::create(int operFlag){

    Operaton* operaton;

    switch(operFlag)

    {

        case OPERATOR_ADD:

            operaton = new OperatonAdd();

            break;

        case OPERATOR_MINUS:

            operaton = new OperatonSub();

            break;

        case OPERATOR_MUTHL:

            operaton = new OperatonMul();

            break;

        case OPERATOR_DIV:

            operaton = new OperatonDiv();

            break;

        default:

            cout<<"输入有错误！"<<endl;

            break;

    }

    return  operaton;

}

在这里操作返回的对象，将业务分的更细致，main的代码可改为

?

#include "stdafx.h"

#include <string>

#include <iostream>

#include "Operaton.h"

#include "OperatonFactory.h"

 

using namespace std;

 

int main(int argc, char* argv[])

{

    int strNumA,strNumB;

    int strOperator;

    cout<<"请输入数字A：\n";

    cin>>strNumA;

    cout<<"请选择运算符号（1,+,2,-,3,*,4,/）：\n";

    cin>>strOperator;

    cout<<"请输入数字B：\n";

    cin>>strNumB;

 

    int strResult = 0;

    Operaton *op;

    OperatonFactory* opFactory = new OperatonFactory();

    op = opFactory->create(strOperator);

    op->numA = strNumA;

    op->numB = strNumB;

    strResult = op->getResult();

    cout<<"得到的结果是："<<strResult;

    return 0;

}

这样，如果继续增加比如求平方，取余就可以不修改main中的内容了。当然现在还没有完全移除if和switch，在下面的历程中会逐一讲到。