简单四则运算计算器的C++实现(含括号和+-*/的优先级判断)

抽空实现了一下严蔚敏的《数据结构》一书中的带优先级的计算器，感觉还是有些收获，特此分享一下^_^;

原理

请参照《严蔚敏：数据结构 第4版》栈相关章节，下面是其计算过程的简单演示；

算数运算符在压栈和出栈时的优先关系(图片源自网格);

代码

一、计算器Demo

// main.cpp
#include "Calculator.h"

int main(int argc, char *agrv[])
{
    CCalculator cc;
    cout << "/\n"\
         << "//      Hello, Dear User! Welcome to Calculator!       //\n"\
         << "//   Tips: Calc - Input any Equation end by \"Enter\"    //\n"\
         << "//         Exit - exit                                 //\n"\
         << "/\n"\
         << "Input your equation pls:\nUsr/> ";

    string eq;
    while (getline(std::cin, eq))
    {
        if (!eq.compare("exit"))
        {
            cout << "/\n"\
                 << "//             Goodbye! Dear User!!!                   //\n"\
                 << "/\n";

            break;
        }
        cout << "Sys/> "<< cc.CalcEquation(eq) << "\n\nUsr/> ";
    }

    return 0;
}

二、计算器类文件

// Calculator.h

#ifndef _CALCULATOR_H_
#define _CALCULATOR_H_

#include 
#include 
#include 
#include 
using namespace std;

/***********************************************************************
类 描 述： CCalculator - 计算器类，对外提供等式计算接口，并返回计算结果，可重复
                        调用，计算不同等式;
编辑时间：2016/12/26
编 辑 者：Chirl
***********************************************************************/

class CCalculator
{
public:
    CCalculator(void);
    ~CCalculator(void);

    /***********************************************************************
    函数功能：对传入的字符串等式进行求解。
    输入参数：eq - 字符串格式的数学算式
    输出参数：返回算式计算结果;
    编辑时间：2016/12/28
    编 辑 者：Chirl
     ***********************************************************************/
    const float CalcEquation(string &eq);
private:
    CCalculator(const CCalculator &c){}
    void operator=(const CCalculator &c){}

    /***********************************************************************
    函数功能：对两个操作数lhs和rhs执行op算数操作。
    输入参数：op必须为算数操作符（+、-、*、/）
              rhs和lhs必须为同类型的值;
    输出参数：返回两个数进行op算数运算后的结果;
    编辑时间：2016/12/26
    编 辑 者：Chirl
     ***********************************************************************/
    template T Operate(T lhs, char op, T rhs) const;

    /***********************************************************************
    函数功能：判断字符c是否为算数运算符;
    输入参数：c - 待判断的字符；
    输出参数：如果c是算数操作符中的值，则返回true，否则false;
    编辑时间：2016/12/26
    编 辑 者：Chirl
     ***********************************************************************/
    bool IsOperator(char c) const;                              

    /***********************************************************************
    函数功能：查询运算符的下标;
    输入参数：c - 待查询的字符；
    输出参数：如果c为运算符，则返回0~6，否则返回7;
    编辑时间：2016/12/26
    编 辑 者：Chirl
     ***********************************************************************/
    int FindOperatorIdx(char c) const;

    /***********************************************************************
    函数功能：比较两个算数运算符的优先级;
    输入参数：bcp - 被比较的运算符；
              cp  - 待比较的算数运算符;
    输出参数：如果cp优先级高，返回'<';cp优先级低，返回'>';
    编辑时间：2016/12/28
    编 辑 者：Chirl
     ***********************************************************************/
    char ComparePriority(char bcp, char cp) const;

    /***********************************************************************
    函数功能：根据优先级，对栈中的数据进行操作;
    输入参数：priority - 优先级符号，< > =;
             op       - 当前待操作的操作符;
    输出参数：bool 返回对当前的操作符是否运算结束;即当前的操作符是否已经成功入栈：
    编辑时间：2016/12/28
    编 辑 者：Chirl
     ***********************************************************************/
    bool OperateDependOnPriority(const char priority, char op);
private:
    typedef struct SOperatorPriority
    {
        char    op;         // 运算符;
        char    pri;        // 优先级;
    }SOP;
    enum EOP                // 基础运算符
    {
      EOP_PLUS  = 0,        // +
      EOP_MINUS = 1,        // -
      EOP_MULTI = 2,        // *
      EOP_DIVID = 3,        // /
      EOP_LBRACKET = 4,     // (
      EOP_RBRACKET = 5,     // )
      EOP_SHAP  = 6,        // #
      EOP_OPCNT = 7,        // 操作符个数;
    };
    const static SOP        s_OP[EOP_OPCNT];    // 存储基本算数运算符;
    const static char       s_OpPriorityTable[EOP_OPCNT][EOP_OPCNT]; // 操作符优先级列表;
    stack<char>             m_OptrStack;        // 操作符栈;
    stack<float>            m_NumStack;         // 数值栈;
    bool                    m_EquationErr;      // 输入的等式有误;
};

template   // 基础四则运算的函数模板在此其实没有必要，直接令类型为float也行;
T CCalculator::Operate(T lhs, char op, T rhs) const 
{
    switch (op) 
    {
    case '+':
        return lhs + rhs;
    case '-':
        return lhs - rhs;
    case '*':
        return lhs * rhs;
    case '/':
        return abs(rhs-0)<0.000001f ? 0xFFFFFFF : lhs / rhs;
    default:
        cout << "Calc/> Your operator is wrong!" << endl;
        break;
    }
    return T();
}


#endif

// Calculator.cpp

#include "Calculator.h"

const CCalculator::SOP CCalculator::s_OP[EOP_OPCNT] = {{'+', EOP_PLUS}, {'-', EOP_MINUS}, \
{'*', EOP_MULTI}, {'/', EOP_DIVID}, {'(', EOP_LBRACKET}, {')', EOP_RBRACKET}, {'#', EOP_SHAP}};

// 为了偷懒，直接将优先级列表存下来，用到直接查询;当然最好总结一下其中的逻辑关系，封装成函数；
const char  CCalculator::s_OpPriorityTable[EOP_OPCNT][EOP_OPCNT] = 
                                  {
                                    {'>','>','<','<','<','>','>'},
                                    {'>','>','<','<','<','>','>'},
                                    {'>','>','>','>','<','>','>'},
                                    {'>','>','>','>','<','>','>'},
                                    {'<','<','<','<','<','=',' '},  // ' ' 表示表达式错误;
                                    {'>','>','>','>',' ','>','>'},
                                    {'<','<','<','<','<',' ','='}
                                  };

CCalculator::CCalculator(void)
 : m_EquationErr(false)
{

}

CCalculator::~CCalculator(void)
{
}

const float CCalculator::CalcEquation(string &eq)
{
    if (eq.empty())
    {

        return 0.0f;
    }
    // 执行预处理;
    size_t idx = eq.find_first_of("=");   // 去除等号;
    if (idx != string::npos)              // npos在这儿表示没有匹配值;
    {
      eq[idx] = ' ';
    }
    m_NumStack.swap(stack<float>());
    m_OptrStack.swap(stack<char>());
    m_OptrStack.push('#');
    m_EquationErr = false;
    eq.append("#");

    float tmpNum = 0.0f; //临时保存数值：
    char  tmpOp  = ' ';  //临时保存操作符;
    int   curIdx = 0;    //当前读取到的字符下标;
    bool  numAdj = false;//两个数字相邻,中间没有符号;   
    istringstream is(eq);
    while (!is.eof() && tmpOp != '#')
    {
        char c;
        if ((curIdx = is.tellg()) == string::npos)
        {
            break;
        }
        c = (is.str())[curIdx];
        if (c >= '0' && c <= '9')           // 当前位置为数值;
        {
            if (numAdj)
            {
                cout << "Calc/> The equation you input is wrong!" << endl;
                return 0.0f;
            }
            tmpNum = 0;
            is >> tmpNum;
            m_NumStack.push(tmpNum);
            numAdj = true;              
        }
        else if (IsOperator(c))                         // 如果是操作符;
        {
            tmpOp = ' ';
            is >> tmpOp;
            char priority = ' ';
            numAdj = false;
            do 
            {
                priority = ComparePriority(m_OptrStack.top(), tmpOp);
                if (priority == ' ' || m_EquationErr)
                {
                    cout << "Calc/> The equation you input is wrong!" << endl;
                    return 0.0f;
                }
            } while (!OperateDependOnPriority(priority, tmpOp));

        }
        else if (c == ' ')
        {
            is.seekg(curIdx+1, ios::beg);
        }
        else    
        {
            cout << "Calc/> The equation you input is wrong!" << endl;
            return 0.0f;
        }
    }

    if (!m_OptrStack.empty() || m_NumStack.size() != 1)
    {
        cout << "Calc/> The equation you input is wrong!" << endl;
        return 0.0f;
    }
    return m_NumStack.top();
}

bool CCalculator::IsOperator(char c) const
{
    return FindOperatorIdx(c) < EOP_OPCNT ? true : false;
}

int CCalculator::FindOperatorIdx(char c) const
{
    int i = 0;
    while (c != s_OP[i].op && i < EOP_OPCNT)
    {
        i++;
    }

    return i;
}

char CCalculator::ComparePriority(char bcp, char cp) const
{
    int bidx = FindOperatorIdx(bcp);
    if (bidx >= EOP_OPCNT)
    {
        return ' ';
    }
    int cidx = FindOperatorIdx(cp);
    if (cidx >= EOP_OPCNT)
    {
        return ' ';
    }
    return s_OpPriorityTable[bidx][cidx];
}

bool CCalculator::OperateDependOnPriority(const char priority, char op)
{
    switch (priority)
    {
    case '<':               // 新操作符优先级大
        m_OptrStack.push(op);
        return true;
    case '>':
        {
            if (m_NumStack.size() < 2)   // 如果剩余数字不足以参与运算，则等式有误;
            {
                m_EquationErr = true;
                return false;
            }
            float rhs = m_NumStack.top();m_NumStack.pop();
            float lhs = m_NumStack.top();m_NumStack.pop();
            m_NumStack.push(Operate(lhs, m_OptrStack.top(), rhs));
            m_OptrStack.pop();
            return false;
        }
    case '=':
        m_OptrStack.pop();
        return true;
    default:
        m_EquationErr = true;
        break;
    }
    return false;
}