又一篇四则运算代码

代码分为两段

一段为将输入分解为TOKEN :  0-9 ( ) + _ * /

一段为根据输入进行计算

第一段

#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <tuple>
#include <assert.h>
using namespace std;

enum CALC_STATUS{
    InitStatus = 0,
    InNumberStatus,
    InIdentStatus,
    EndLineStatus,
    BadStatus
};

enum Token_Type{
    NumberTokenType,
    LparamTokenType,
    RparamTokenType,
    AddTokenType,
    SubTokenType,
    MulTokenType,
    DivTokenType,
    BadTokenType
};

typedef struct TOKEN_TUPLE{
    TOKEN_TUPLE(const std::string& token,const Token_Type& type){
        s = token;
        t = type;
    }
    TOKEN_TUPLE(){};
    TOKEN_TUPLE(const TOKEN_TUPLE& tt){
        s = tt.s;
        t = tt.t;
    }
    std::string s;
    Token_Type t;
};

std::deque<TOKEN_TUPLE> tokenDeque;


void InsertToken(const std::string& token,const Token_Type& type){
    tokenDeque.push_front(TOKEN_TUPLE(token,type));
}


bool IsIdent(const char cc){
    return ( cc == '+' ||
             cc == '-' ||
             cc == '*' ||
             cc == '/' ||
             cc == '(' ||
             cc == ')' );
}

void InsertIdentToken(const std::string& token)
{
    Token_Type tokenType = BadTokenType;
    if(token.size() != 1 || !IsIdent(token[0]))
        return;
    if(token[0] == '+'){
        tokenType = AddTokenType;
    }else if(token[0] == '-'){
        tokenType = SubTokenType;
    }else if(token[0] == '*'){
        tokenType = MulTokenType;
    }else if(token[0] == '/'){
        tokenType = DivTokenType;
    }else if(token[0] == '('){
        tokenType = LparamTokenType;
    }else if(token[0] == ')'){
        tokenType = RparamTokenType;
    }

    InsertToken(token,tokenType);
}

bool ParseInput(const std::string& input)
{
    bool bRet = false;
    CALC_STATUS status = InitStatus;
    size_t begPos , endPos ;
    bool foundPoint = false;

    tokenDeque.clear();

    for(size_t index= 0;index < input.size();++index){
        switch(status){
        case InitStatus:
            if(isspace(input[index])){
                continue;
            }else if(isdigit(input[index])){
                status =  InNumberStatus;
                begPos = index;
                continue;
            }else if( IsIdent(input[index]) ){
                status =  InIdentStatus;
                begPos = index;
                continue;
            }else{
                status =  BadStatus;
                //std::cout << "parse bad input,index is " << index << std::endl;
                break;
            }
            break;
        case InNumberStatus:
            if(isdigit(input[index])){
                status =  InNumberStatus;
                continue;
            }else if(input[index]=='.'){
                if(foundPoint){
                    status =  BadStatus;
                    //std::cout << "parse bad input,index is " << index << std::endl;
                    break;
                }
                status =  InNumberStatus;
                foundPoint = true;
                continue;
            }else if( IsIdent(input[index])){
                endPos = index;
                InsertToken(input.substr(begPos,endPos-begPos),NumberTokenType);
                begPos = index;
                status =  InIdentStatus;
                foundPoint = false;
                continue;
            }else if(isspace(input[index])){
                endPos = index;
                InsertToken(input.substr(begPos,endPos-begPos),NumberTokenType);
                status =  InitStatus;
                foundPoint = false;
                continue;
            }
            else{
                status =  BadStatus;
                break;
            }
        case InIdentStatus:
            endPos = index;
            InsertIdentToken(input.substr(begPos,endPos-begPos));
            status =  InitStatus;
            --index;
            continue;
        default:
            status =  BadStatus;
            break;
       }//switch(status)
    }//for(size_t index= 0;index < input.size();++index)

    if(status !=  BadStatus &&  status !=  InitStatus){
        endPos = std::string::npos;
        if(status == InNumberStatus)
        {
            InsertToken(input.substr(begPos,endPos-begPos),NumberTokenType);
        }else if(status == InIdentStatus){
            InsertIdentToken(input.substr(begPos,endPos-begPos));
        }

        bRet = true;
    }else if(status ==  InitStatus){
        bRet = true;
    }

    if(!bRet)
        tokenDeque.clear();
    return bRet;
}

void PrintErrorMsg(const string& input){
    std::cout << std::endl << "test error!!" << std::endl;
    std::cout << "input is " << input << "."<< std::endl;
}



void TestInput(const string& input,bool result,size_t tokenCount){
    static int i = 1;
    if( ParseInput(input) != result) {
        PrintErrorMsg(input);
        std::cout << "result is not  " << result << std::endl<< std::endl;
    }else if( tokenDeque.size() != tokenCount ){
        PrintErrorMsg(input);
        std::cout <<"tokenCount is " <<tokenDeque.size() << " not  " << tokenCount << std::endl <<std::endl;
    }else{
        std::cout << i << "	times test pass!" << std::endl;
    }
    i++;
}



bool GetNextToken(TOKEN_TUPLE& tokenTuple)
{
    if(tokenDeque.empty()){
        tokenTuple.t = BadTokenType;
        return false;
    }
    tokenTuple = tokenDeque.back();
    tokenDeque.pop_back();
    return true;
}

void UngetToken(const TOKEN_TUPLE& tokenTuple){
    tokenDeque.push_back(tokenTuple);
}

bool ParsePression(double& value);

bool ParsePrimaryExpression(double& value)
{
    bool ret = false;
    bool minusFlag = false;
    TOKEN_TUPLE tt;

    GetNextToken(tt);
    if (tt.t == SubTokenType) {
        minusFlag = true;
    } else {
        UngetToken(tt);
    }

    GetNextToken(tt);
    if(tt.t == NumberTokenType){
        value = std::stod(tt.s);
    }else if(tt.t == LparamTokenType){
        if(!ParsePression(value))
            return false;
        GetNextToken(tt);
        if(tt.t != RparamTokenType){
            return false;
        }
    }else{
        UngetToken(tt);//??
    }

    if(minusFlag)
        value = -value;

    ret =true;
    return ret;
}

bool ParseTerm(double& value){
    bool ret = false;
    double v1;
    double v2;
    TOKEN_TUPLE tt;

    if(!ParsePrimaryExpression(v1) )
        return ret;

    for(;;){
        GetNextToken(tt);
        if(tt.t != MulTokenType &&
                tt.t != DivTokenType&&ret){
            UngetToken(tt);
            break;
        }
        ParsePrimaryExpression(v2);
        if(tt.t == MulTokenType){
            v1 = v1*v2;
        }else if(tt.t == DivTokenType){
            if(v2 ==0.0)
                return ret;
            v1 = v1/v2;
        }
    }

    value = v1;
    ret = true;
    return ret;
}

bool ParsePression(double& value){
    bool ret = false;
    double v1;
    double v2;
    TOKEN_TUPLE tt;

    if(tokenDeque.empty())
        return ret;

    if(!ParseTerm(v1))
        return ret;
    for(;;){
        GetNextToken(tt);
        if(tt.t != AddTokenType && tt.t != SubTokenType){
            UngetToken(tt);
            break;
        }
        ParseTerm(v2);
        if(tt.t == AddTokenType){
            v1 = v1+v2;
        }else if(tt.t == SubTokenType){
            v1 = v1-v2;
        }else{
            UngetToken(tt);
        }
    }


    value = v1;
    ret = true;
    return ret;
}


int main(int argc, char *argv[])
{
//    std::string input;
//    cin >> input;
//    cout << input << endl;
//    TestInput("2",true,1);
//    TestInput("0.2",true,1);
//    TestInput("2 3",true,2);
    TestInput("2.467  + 3",true,3);
    double d;
    bool ret = ParsePression(d);
//    TestInput("()2.467  + 3",true,5);
//    TestInput("3.14 + ( 2.43-1) /3 *(2*6)",true,15);

//    TestInput(".()2.467  + 3",false,0);
//    TestInput("aas+2()2.467  + 3",false,0);
//    TestInput("2.46.7  + 3",false,0);
//    TestInput("2.4(6.7  + 3",true,5);

    return 0;
}

显示结果

第二段

// 11111.cpp : 定义控制台应用程序的入口点。
//
 
#include "stdafx.h"
#include <string>
#include <iostream>
 
 
using namespace std;
 
std::string s1 = "2+3-2";
std::string s2 = "2+3*3";
std::string s3 = "2+(3*3)";
std::string s4 = "()2+(3*3)";
 
int gStringIndex = 0;
 
bool ParseExPression(const std::string& s, int& v);
 
#define ERROR_MSG   
std::cerr << "Error. Func : " << __FUNCTION__ << ".	Line : " << __LINE__ << std::endl;   
std::cerr << "expression is " << s << ".  error index is " << gStringIndex << std::endl;  
exit(0);
 
 
bool ParsePrimaryExpression(const std::string& s, int& v)
{
    bool minusFlag = false;
 
    if (s[gStringIndex] == '-') {
        minusFlag = true;
        ++gStringIndex;
    }
 
    if (isdigit(s[gStringIndex])) {
        std::string token = s.substr(gStringIndex, 1);
        v = stoi(token);
        gStringIndex++;
        if (minusFlag)
            v = -v;
        return true;
    }
    else if (s[gStringIndex] == '(')
    {
        gStringIndex++;
        if (!ParseExPression(s, v)) {
            ERROR_MSG;
        }
        if (s[gStringIndex] == ')') {
            gStringIndex++;
            if (minusFlag)
                v = -v;
            return true;
        }
    }
    else {
        ERROR_MSG;
    }
         
 
 
 
    return false;
}
 
 
bool ParseTerm(const std::string& s, int& v)
{
    int v1;
    int v2;
    char ident = 0;
 
    if (!ParsePrimaryExpression(s, v1)) {
        ERROR_MSG;
    }
    while (1) {
        if (s[gStringIndex] != '*' &&
            s[gStringIndex] != '/')
        {
            break;
        }
        else {
            ident = s[gStringIndex];
            ++gStringIndex;
        }
 
        if (!ParsePrimaryExpression(s, v2)) {
            ERROR_MSG;
        }
 
        if (ident == '*')
        {
            v1 = v1*v2;
        }
        else if (ident == '/' && v2 != 0) {
            v1 = v1 / v2;
        }
        else {
            ERROR_MSG;
        }
    }
 
    v = v1;
    return true;
}
 
bool ParseExPression(const std::string& s, int& v)
{
    int v1;
    int v2;
    char ident = 0;
 
 
    if (!ParseTerm(s, v1)) {
        ERROR_MSG;
    }
 
    while (1) {
        if (s[gStringIndex] != '+' &&
            s[gStringIndex] != '-')
        {
            break;
        }
        else {
            ident = s[gStringIndex];
            ++gStringIndex;
        }
 
        if (!ParseTerm(s, v2)) {
            ERROR_MSG;
        }
 
        if (ident == '+')
        {
            v1 = v1+v2;
        }
        else if (ident == '-') {
            v1 = v1 - v2;
        }
        else {
            ERROR_MSG;
        }
 
    }
 
    v = v1;
    return true;
}
 
 
bool  ParseInput(const std::string& s)
{
    gStringIndex = 0;
    int v;
    if (!ParseExPression(s, v)) {
        ERROR_MSG;
    }
         
    std::cout << s << " = " << v << endl;
 
 
    return true;
}
 
int main()
{
    ParseInput(s1);
    std::cout << std::endl << std::endl;
 
    ParseInput(s2);
    std::cout << std::endl << std::endl;
 
    ParseInput(s3);
    std::cout << std::endl << std::endl;
 
    ParseInput(s4);
    std::cout << std::endl << std::endl;
 
    return 0;
}

显示结果