再探利用C++的STL和堆栈编程思想实现数学四则运算计算结果

此次修改了上次的版本，利用了堆栈的编程思想，实现了支持括号的四则运算

跟上个版本一样,吧表达式存储到a.txt中：

结果保存在b.txt中：

 

堆栈编程思路：

1. 建立两个堆，一个字符堆，用于存储+、-、*、/、%、=；一个数字堆，用于存储数字

2. 创建两个字符,一个存储堆顶的操作符，一个存储表达式中的操作符

3. 建立一个二维表，利用2.中的两个操作符转化为行和列，在二维表中找到对应的判断

4. 若是小于，则表示，表达式中的操作符优先级比原先的操作符优先级高，直接压入堆中存储

5. 若是大于，则表示堆顶的操作符优先级高，所以先计算，把数字堆中的两个数弹出，计算结果，压回堆中存储，并把表达式中的操作符压入字符堆中

6. 若为0，则表示表达式不合法

7. 若为=，则有两种情况，一个是表达式计算完成，把结果存储到answer中。另外一种是括号配对了，需要把前括号pop了

 

以上是主思路，次思路跟上次一样：

1. 打开a.txt;

2. 利用getline吧每行的表达式读出来，存入string类对象中；

3. 循环读取，循环计算结果;

4. 循环完成，把answer中的结果存储到b.txt;

 

差不多就这样，下面附上代码：

// Arithmetic3.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <deque>
#include <stack>
#include <stdio.h>

using namespace std;

                //+   -   *   /   %   (   )   =
char ss[8][8] ={{'>','>','<','<','<','<','>','>'},
                {'>','>','<','<','<','<','>','>'},
                {'>','>','>','>','>','<','>','>'},
                {'>','>','>','>','>','<','>','>'},
                {'>','>','>','>','>','<','>','>'},
                {'<','<','<','<','<','<','=','0'},
                {'>','>','>','>','>','0','>','>'},
                {'<','<','<','<','<','<','0','='}};
//大于号，弹出数字，进行计算，小于号，压入堆栈中

//把字符转化成相应的行和列
void getRowCol (const char stackCh, const char ch, int& row, int& col)
{
    switch (stackCh)
    {
    case '+':
        row = 0;
        break;
    case '-':
        row = 1;
        break;
    case '*':
        row = 2;
        break;
    case '/':
        row = 3;
        break;
    case '%':
        row = 4;
        break;
    case '(':
        row = 5;
        break;
    case ')':
        row = 6;
        break;
    case '=':
        row = 7;
        break;
    }
    switch (ch)
    {
    case '+':
        col = 0;
        break;
    case '-':
        col = 1;
        break;
    case '*':
        col = 2;
        break;
    case '/':
        col = 3;
        break;
    case '%':
        col = 4;
        break;
    case '(':
        col = 5;
        break;
    case ')':
        col = 6;
        break;
    case '=':
        col = 7;
        break;
    }

}

//写入文件
void writeAnswer(vector<int>& iAnswer)
{
    ofstream ofs("b.txt");
    for(vector<int>::size_type ix = 0; ix != iAnswer.size(); ix++)
    {
        ofs << iAnswer[ix] << '\n';
    }
    ofs.close();
}


void countAnswer(vector<int>& iAnswer, string& str)
{
    int temp = 0;
    int row = 0 ,col = 0;
    stack<int> iStk;            //定义数据堆
    stack<char> cStk;            //定义字符堆
    char stackCh = '\0';
    char ch = '\0';
    cStk.push('=');             //先把=压入字符堆中，以备匹配等号
    for (string::size_type ix = 0; ix != str.size(); ix++)
    {
        //如果是数字，先判断下一个字符是否也是数字，如果不是，就压入数据堆中
        if (str[ix] >= '0' && str[ix] <= '9')
        {
            temp = str[ix] - '0' + temp * 10;
            if (str[ix + 1] < '0' || str[ix + 1] > '9')
            {
                iStk.push(temp);
            }
        }
        else
        {
/*            iStk.push(temp);*/
            temp = 0;
            stackCh = cStk.top();       //弹出字符堆的堆顶字符
            ch = str[ix];                //读取字符串中的字符
            if (ch == '=' || ch == ')') //遇到 = 号，或者），先执行判断
            {
                ix--;
            }
            getRowCol(stackCh,ch,row,col); ////把字符转化成相应的行和列
            switch(ss[row][col])
            {
            case '=':  //遇到括号匹配，或者=号匹配，计算结束
                if ( ch == '=')
                {
                    iAnswer.push_back(iStk.top());
                    return ;
                }
                else
                {
                    cStk.pop();
                    ix++;
                }

                break;
            case '>':  //取出堆中的两个数据，执行计算
                {
                    int num2 = iStk.top();
                    iStk.pop();
                    int num1 = iStk.top();
                    iStk.pop();
                    stackCh = cStk.top();
                    cStk.pop();
                    if (ch != '=' && ch != ')')
                    {
                        cStk.push(ch);
                    }
                    switch(stackCh)
                    {
                    case '+':
                        num1 += num2;
                        break;
                    case '-':
                        num1 -= num2;
                        break;
                    case '*':
                        num1 *= num2;
                        break;
                    case '/':
                        num1 /= num2;
                        break;
                    case '%':
                        num1 %= num2;
                        break;
                    }
                    iStk.push(num1);
                    break;
                }
            case '<': //压入堆中
                cStk.push(ch);
                break;
            case '0': //表达式错误
                cout << "error arithmetic" << endl;
                return ;
            }
        }
    }
}


void countMath()
{
    ifstream ifs("a.txt");
    if (!ifs.is_open())
    {
        ifs.clear();
        fstream fs("a.txt",ios_base::out); //如果打开失败就创建文件a.txt
        fs.close();
        ifs.open("a.txt");
    }
    string temp;
    deque<string> sDeq;
    while (!ifs.eof())
    {
        getline(ifs,temp);                //按行读取数据，存储到双端队列中
        sDeq.push_back(temp);
    }

    ifs.close();

    vector<int> iAnswer;
    for (deque<string>::size_type ix = 0; ix != sDeq.size(); ix++)
    {
        string str;
        str = sDeq.front();
        sDeq.pop_front();
        ix--;
        //计算每一行的表达式
        countAnswer(iAnswer,str);
    }

    writeAnswer(iAnswer);
}

int _tmain(int argc, _TCHAR* argv[])
{
    countMath();
    return 0;
}