简单算术表达式C++实现

最新推荐文章于 2024-10-22 17:39:02 发布

原创最新推荐文章于 2024-10-22 17:39:02 发布 · 1.6k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#C++ #简单表达式实现

c++ 专栏收录该内容

8 篇文章

订阅专栏

输入的算术表达式是中缀表达式，由于操作符的优先级不同，不能直接进行求解，而后缀表达式的计算不需要判别操作符的优先级，所以我实现算术表达式的思路是：1）应用堆栈将中缀表达式转化为后缀表达式，2）用堆栈实现后缀表达式求值。
用堆栈实现后缀表达式求值的过程：从左到右读入后缀表达式的各项，并根据读入的对象判断执行何种操作，有以下3中情况：
1) 当读入的是一个运算数时，把它压入栈中；
2) 当读入的是一个运算符时，就从栈中弹出适当数量的运算数并进行计算，计算结果再压回到栈中；
3) 处理完整个后缀表达式之后，栈顶上的元素就是表达式的结果。
应用堆栈将中缀表达式转换为后缀表达式的基本过程为：从头到尾读取中缀表达式的每个对象，对不同对象按不同情况处理：
1) 如果遇到空格则认为是分隔符，无需处理；
2) 若遇到运算数，则直接输出；
3) 若是左括号，则将其压入至栈中；
4) 若遇到的是右括号，表明括号内的中缀表达式已经扫描完毕，将栈顶的运算符弹出并输出，直到遇到左括号（左括号也出栈，但不输出）；
5) 若遇到的是运算符，若该运算符的优先级大于栈顶运算符的优先级，则把它压入栈中；若该运算符的优先级小于等于栈顶运算符时，将栈顶运算符弹出并输出，在比较新的栈顶运算符，按这样的处理方法，直到该运算符大于栈顶运算符优先级为止，然后将该运算符压栈；
6) 若中缀表达式中的各对象处理完毕，则把堆栈中保留的运算符一并输出。
在代码实现的过程中，首先我们要定义一个栈，因为在后缀表达式求值的过程中，栈是用来存运算数的；在中缀转换为后缀表达式的过程中，栈是用来存放操作符的。所以在实现栈的时候我用了模板。栈的实现如下：
// Stack.h

#include<vector>
template <class T>
class Stack{
public:
    void push(const T&);
    T pop();
    T peek();//该函数只是返回最顶端的元素，并不删除
    bool empty();
private:
    std::vector<T> _stack;
};
template<class T>
void Stack<T>::push(const T& a){
    _stack.push_back(a);
}
template<class T>
T Stack<T>::pop(){
    //在要用到出栈的时候一定要保证栈不为空
    auto it = _stack.end();
    auto c = *(it - 1);
    _stack.pop_back();
    return c;
}
template<class T>
bool Stack<T>::empty(){
    return _stack.begin() == _stack.end();
}
template<class T>
T Stack<T>::peek(){
    auto it = _stack.end();
    return *(it - 1);
}

定义相应的运算符的优先级，我用整数的大小来定义优先级的大小，对应的函数实现如下：

int op_pri(const char& a){
    switch (a){
    case ')':
        return 0;
    case '+':case '-':
        return 1;
    case '*':case'/':
        return 2;
    case '(':
        return 3;
    }
}

在实现优先级的时候，当输入为左括号时，需要无条件进栈，所以左括号的优先级要最高。碰到右括号时要无条件出栈直到那个栈顶的操作符是左括号。所以右括号的优先级我定义为最低。但是要注意当当前的运算符为右括号时，证明括号内的中缀表达式已经扫描完毕，要将栈顶运算符弹出，直到左括号（这时左括号出栈，但是不用加入到运算中）；还要注意当运算符是左括号时，因为我把左括号定义为了最高优先级了，如果按正常的情况，当栈顶是左括号时，应当会马上输出但是这不符合我们的要求，希望的是紧接的运算符能无条件的入栈，所以在代码的实现过程中这是中特殊的情况用个if语句强调。
接下来是对中缀转换为后缀表达式实现的最主要的功能函数，就是运算符的出入栈的情况：

int oper_cp(const char&a, const char& b){

    int c = op_pri(a);
    int d = op_pri(b);
    if (c == 0 && d == 3)
        return -1;//当左括号碰到右括号时，定义为一个特殊状态，此状态是直接把栈中的左括号操作符弹出
    //右括号也不进栈
    else if (d == 3)//定义优先级时，以整数大小来对应优先级的大小。但是当输入为左括号时，需要无条件
        //进栈，所以左括号的优先级要最高。碰到右括号时要无条件出栈直到那个栈顶的操作符是左括号。所以
        //右括号的优先级要最低。
        //但是在右括号进栈后，若紧接的操作符是+、-、*、/的话，需要进栈，这个条件语句就是在这种情况下
        //对应的操作符直接进栈
        return 1;
    else if (c > d){
        return 1;
    }
    else
        return 0;

}

有了上述两个函数的支持，接下来就是直接对中缀表达式求值的函数，这些问题只是逻辑问题，我的代码实现如下：

void exp(Stack<double> &val, Stack<char> &op){
    char c{};
    string s{};
    do
    {
        c = getchar();

        if ((c >= '0'&&c <= '9') || c == '.')
        {
            s.push_back(c);
            continue;
        }
        else
        {
            if (s != "\0")
            {
                val.push(atof(s.c_str()));
                s = "\0";
            }

        }
        if (c == '+' || c == '-' || c == '*' || c == '/' || c == ')' || c == '(')
        {
            char b;
            if (op.empty()){
                op.push(c);
                continue;
            }
            while (1)
            {
                if (!op.empty())
                    b = op.peek();
                else
                {
                    op.push(c);
                    break;
                }

                int m = oper_cp(c, b);
                if (m == 1)
                {
                    op.push(c);
                    break;
                }
                if (m == 0)
                {
                    b = op.pop();
                    double c, d;
                    d = val.pop();
                    c = val.pop();
                    switch (b)
                    {
                    case '+':
                        val.push(c + d);
                        break;
                    case '-':
                        val.push(c - d);
                        break;
                    case'*':
                        val.push(c*d);
                        break;
                    case'/':
                        val.push(c / d);
                        break;
                    }
                    continue;
                }
                if (m == -1)
                {
                    op.pop();
                    break;
                }
            }
        }
    } while (c != '\n');
    while (!op.empty()){
        char b = op.pop();
        double e, d;
        d = val.pop();
        e = val.pop();
        switch (b)
        {
        case '+':
            val.push(e + d);
            break;
        case '-':
            val.push(e - d);
            break;
        case'*':
            val.push(e*d);
            break;
        case'/':
            val.push(e / d);
            break;
        }
    }

}

调用这些函数的main函数如下：

#include<iostream>
#include<string>
#include "Stack.h"
using namespace std;
void exp(Stack<double> &val, Stack<char> &op);
int op_pri(const char& );
int oper_cp(const char&a, const char& b);
int  main(){
    Stack<double> val;
    Stack<char> op;
    exp(val, op);
    cout << val.pop();
}

int oper_cp(const char&a, const char& b){

    int c = op_pri(a);
    int d = op_pri(b);
    if (c == 0 && d == 3)
        return -1;//当左括号碰到右括号时，定义为一个特殊状态，此状态是直接把栈中的左括号操作符弹出
    //右括号也不进栈
    else if (d == 3)//定义优先级时，以整数大小来对应优先级的大小。但是当输入为左括号时，需要无条件
        //进栈，所以左括号的优先级要最高。碰到右括号时要无条件出栈直到那个栈顶的操作符是左括号。所以
        //右括号的优先级要最低。
        //但是在右括号进栈后，若紧接的操作符是+、-、*、/的话，需要进栈，这个条件语句就是在这种情况下
        //对应的操作符直接进栈
        return 1;
    else if (c > d){
        return 1;
    }
    else
        return 0;

}
int op_pri(const char& a){
    switch (a){
    case ')':
        return 0;
    case '+':case '-':
        return 1;
    case '*':case'/':
        return 2;
    case '(':
        return 3;
    }
}
void exp(Stack<double> &val, Stack<char> &op){
    char c{};
    string s{};
    do
    {
        c = getchar();

        if ((c >= '0'&&c <= '9') || c == '.')
        {
            s.push_back(c);
            continue;
        }
        else
        {
            if (s != "\0")
            {
                val.push(atof(s.c_str()));
                s = "\0";
            }

        }
        if (c == '+' || c == '-' || c == '*' || c == '/' || c == ')' || c == '(')
        {
            char b;
            if (op.empty()){
                op.push(c);
                continue;
            }
            while (1)
            {
                if (!op.empty())
                    b = op.peek();
                else
                {
                    op.push(c);
                    break;
                }

                int m = oper_cp(c, b);
                if (m == 1)
                {
                    op.push(c);
                    break;
                }
                if (m == 0)
                {
                    b = op.pop();
                    double c, d;
                    d = val.pop();
                    c = val.pop();
                    switch (b)
                    {
                    case '+':
                        val.push(c + d);
                        break;
                    case '-':
                        val.push(c - d);
                        break;
                    case'*':
                        val.push(c*d);
                        break;
                    case'/':
                        val.push(c / d);
                        break;
                    }
                    continue;
                }
                if (m == -1)
                {
                    op.pop();
                    break;
                }
            }
        }
    } while (c != '\n');
    while (!op.empty()){
        char b = op.pop();
        double e, d;
        d = val.pop();
        e = val.pop();
        switch (b)
        {
        case '+':
            val.push(e + d);
            break;
        case '-':
            val.push(e - d);
            break;
        case'*':
            val.push(e*d);
            break;
        case'/':
            val.push(e / d);
            break;
        }
    }

}