工厂模式

今天看完设计模式的第一节，工厂模式。现在将源代码写下，记录每一个脚印。

工厂模式：用一个工厂类管理其他类。这样代码的灵活性更强。

#include <QtCore/QCoreApplication>
#include <iostream>
#include <algorithm>
using namespace std;


//计算类的基类，所有新计算方式都继承本类，可以让程序灵活性更强。
class Calculate
{
public:
    Calculate(){}
    Calculate(const double& PreOperation,const double& BackOperation):
        PreOperation(PreOperation),BackOperation(BackOperation){}
    virtual inline double GetResult() const = 0;
protected:
    double PreOperation;
    double BackOperation;
};

//计算类的子类：加法类
class CalculateAdd:public Calculate
{
public:
    CalculateAdd(const double& PreOperation,const double& BackOperation):
        Calculate(PreOperation,BackOperation){}
    virtual ~CalculateAdd(){}
    inline double GetResult() const {return PreOperation + BackOperation; }
};

//计算类的子类：减法类
class CalculateSubstraction:public Calculate
{
public:
    CalculateSubstraction(const double& PreOperation,const double& BackOperation):
        Calculate(PreOperation,BackOperation){}
    virtual ~CalculateSubstraction(){}
    inline double GetResult() const {return PreOperation - BackOperation; }
};


//工厂类，管理所有计算的类
class CalculateFactory
{
public:
    inline CalculateFactory(char Operation):Operation(Operation){}
    double GetResult(const double& PreOperation,const double& BackOperation)
    {
        switch(Operation)
        {
        case '+':
            p = new CalculateAdd(PreOperation,BackOperation);
            return p->GetResult();
            break;
        case '-':
            p = new CalculateSubstraction(PreOperation,BackOperation);
            return p->GetResult();
            break;
        default:
            cout<<"操作数有问题"<<endl;
            break;
        }
        return 0;
    }
    virtual ~CalculateFactory()
    {
        if( p != NULL )
            delete p;
    }

private:
    char Operation;  //运算符
    Calculate *p;
};

//函数对象
class FunctionObject
{
public:
    FunctionObject(){}
    bool operator()(const char& s)
    {
        if( '+' == s || '-' == s)
            return true;
        return false;
    }
};


//输入处理类，对用户输入的字符串进行处理，也可以写子类，添加新的解析方式。
class InputOperation
{
public:
    InputOperation(){}
    InputOperation(string InputString):InputString(InputString)
    {
        InputOperationAnalysis();
    }
    virtual ~InputOperation(){}
    inline double GetPreOperation() const {return PreOperation; }
    inline double GetBackOperation() const { return BackOperation; }
    inline char GetOperation() const {return Operation;}
private:
    string InputString;
    char Operation;
    double PreOperation;  //前操作数
    string PreOperationString; //前操作数的string类型
    double BackOperation;  //后操作数
    string BackOperationString; //前操作数的string类型
    virtual void InputOperationAnalysis()
    {
        if( InputString.empty() )
            return;
        string::iterator StringIter = find_if(InputString.begin(),InputString.end(),FunctionObject());
        Operation = (*StringIter);
        for( string::iterator Iter = InputString.begin(); Iter != StringIter; ++Iter)
            PreOperationString.push_back((*Iter));
        for( string::iterator Iter = StringIter + 1; Iter != InputString.end(); ++Iter)
            BackOperationString.push_back((*Iter));
        PreOperation = atof(PreOperationString.c_str());
        BackOperation = atof(BackOperationString.c_str());
    }
};


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    string OperationException;
    cout<<"请输入表达式：";
    cin>>OperationException;
    InputOperation *ino = new InputOperation(OperationException);
    CalculateFactory *calf = new CalculateFactory(ino->GetOperation());
    cout<<"结果是："<<calf->GetResult(ino->GetPreOperation(),ino->GetBackOperation())<<endl;
    return a.exec();
}