在 C++ 中使用堆栈评估后缀

Question

#include <iostream>
#include <sstream>
#include <stack>
#include <limits>
#include <string>
using namespace std;

int main()
{
    string input;
    cout << "Enter a postfix expression: " << endl;
    getline(cin, input);

    int operand1, operand2, result,number;
    stack<char>operation;

    stringstream temp;

    int i=0;
    while (i < input.length())
    {
        if (isdigit(input[i]))
        {
            operation.push(input[i]);
        }
        else
        {
            operand2 = operation.top();
            temp << operation.top();
            operation.pop();

            operand1 = operation.top();
            temp << operation.top();
            operation.pop();

            switch(operand1,operand2)
            {
                case '+': result=operand1 + operand2;
                break;

                case '-': result=operand1 - operand2;
                break;

                case '*': result=operand1 * operand2;
                break;

                case '/': result=operand1 / operand2;
                break;
            }
            operation.push(result);
        }
        i++;
    }
    cout << "The result is: "<<temp.str()<<endl;
    cin.ignore(numeric_limits<streamsize>::max(), '\n');

    return 0;
}

我更改了代码并设法获取“pop”值，但操作不起作用。

Answer 1

你可能的意思

switch(input[i])

是

switch(operation.top())

Answer 2

更新对代码更改的响应

---

我可以确认您更改了代码，但不是以一种好的方式。

1. 该代码主要具有它已经存在的所有缺陷，甚至还有一些缺陷。
2. 现在将操作数组合成字符串流有什么好处？
3. 您现在打开（操作数1，操作数2）...
   • 两者都未初始化
   • (operand1,operand2) 在此上下文中基本上表示 (operand2)（序列运算符)
   • 您的分支标签是...运算符 (+-/*)

4. 你现在打印最终结果，它是输入中所有数字的串联（如果你到达程序末尾而没有崩溃） ？

在以前错误的事情中，仍然应该修复

1. 堆栈计算器的心理模型。
   • 数字（整数）是操作数（因此 9、100、39829 是有效操作数）
   • +-/* 是运算符（运算符 对操作数进行操作）
   • 堆栈是操作数堆栈，不是运算符堆栈（运算符不必记住，因为它们会立即计算）
   • 数字由 1 个或多个连续数字 (0123456789) 组成；因此，您需要先读取几个字符，然后才能将数字“压入”操作数堆栈
   • 运算符 +-/* 采用2 操作数，因此对大小<2的堆栈上的任何操作都是错误的（您需要检查这一点，否则程序会在尝试访问不存在或包含垃圾的内存时崩溃）。

这应该足以让您开始。

我认为有两件事是积极的：

1. 你的程序可以编译。 +1 为您实际上在那里使用编译器:)
2. 您将重复的 operation.push(result) 从开关中取出，因此它不再重复。编码风格+1...

我希望您可以从中了解到代码不是很好（温和地说），我真的认为一些基本练习是有序的：
1. 编写一个简单的 for 循环，将数字 1 到 10 打印到控制台
1. 编写一个简单的 while 循环来打印用户输入的单词
1. 使用一个简单的循环打印 1 到 50 之间所有 7 的倍数的数字
1. 每当用户输入字母 a、b、k 或 z 之一时，使用 switch 语句打印“yes”
2. 创建一个简单的循环，仅打印相同字符后面的每个字符的输入字符（因此“abccdefgghijkllmabcdd”将变为“cgld”）
1. 使用相同的循环，但这次打印紧随相同单词的每个单词（因此“不，不，你不应该弹出，弹出，而是推，弹出”变成“不弹出”）

这应该会让您感受到事物的实际运作方式，而无需猜测或“神奇因素”。

哦，别忘了，我在下面为您实现了整个过程。我不建议你盲目地复制它（这对你的老师来说是相当明显的:)）但是如果你想知道我上面所有的话是什么意思，你可以看一眼:)

---

1. 您正在推送松散的数字，而不是已解析的数字

2. 在第 31 行中，您弹出一个可能为空的堆栈（导致段错误，除非您使用调试模式 STL编译器上的标志）

只是为了好玩：

#include <iostream>
#include <stack>
#include <vector>
#include <limits>
#include <string>
#include <stdexcept>
#include <iterator>
#include <fstream>

using namespace std;

    template <class T>
        static void dumpstack(std::stack<T> s/*byval!*/)
    {
        std::vector<T> vec;

        while (!s.empty())
        {
            vec.push_back(s.top());
            s.pop();
        }

        std::copy(vec.rbegin(), vec.rend(), std::ostream_iterator<int>(std::cout, " "));
    }

    class calc
    {
        private:
            std::stack<int> _stack;
            int _accum;
            bool _pending;

            void store(/*store accumulator if pending*/)
            {
                if (_pending)
                {
                    _stack.push(_accum);
                    _pending = false;
                    _accum = 0;
                }
            }

        public:
            calc() : _accum(0), _pending(false) 
            {
            }

            void handle(char ch)
            {
                switch (ch)
                {
                    case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
                        _pending = true;
                        _accum *= 10;
                        _accum += ch-'0';
                        break;
                    case '+': case '-': case '/': case '*':
                        {
                            store();
                            if (_stack.size()<2)
                                throw std::runtime_error("stack underflow");

                            int op2 = _stack.top(); _stack.pop();
                            int op1 = _stack.top(); _stack.pop();
                            switch (ch)
                            {
                                case '+': _stack.push(op1 + op2); break;
                                case '-': _stack.push(op1 - op2); break;
                                case '/': _stack.push(op1 / op2); break;
                                case '*': _stack.push(op1 * op2); break;
                            }

                            // feedback to console:
                            std::cout << std::endl << "(evaluated: " << op1 << " " << ch << " " << op2 << " == " << _stack.top() << ")" << std::endl;
                            dump();
                        }
                        break;
                    default:
                        store(); // todo: notify of ignored characters in input?
                }
            }

            void dump() const
            {
                dumpstack(_stack);
            }
    };

    int main() 
    {
        cout << "Enter postfix expressions: " << endl;
        calc instance;

        try
        {
            while (std::cin.good())
            {
                char ch = std::cin.get();
                instance.handle(ch);
            }
            std::cout << "Final result: "; 
            instance.dump();

            return 0;
        } catch(const std::exception& e)
        {
            std::cerr << "E: " << e.what() << std::endl;
            return 255;
        }

    }

测试输出：（请注意，您可以继续剩余的、部分评估的、按回车后堆栈）

Enter postfix expressions: 
1 2 3 +4 * - / 1333 *

(evaluated: 2 + 3 == 5)
1 5 
(evaluated: 5 * 4 == 20)
1 20 
(evaluated: 1 - 20 == -19)
-19 E: stack underflow

Answer 3

从输入表达式的解析开始，代码有很多问题。实际崩溃很可能是由于以下事实：如果您输入类似 "12+" 的内容，您将推送 '1' 和 '2' 到堆栈中（注意：字符 1 和 2，而不是值 1 和 2！！！），然后尝试提取两个操作数和一个从未插入到堆栈中的运算符。

在解析输入时，您正在逐个字符地读取，并且仅使用第一个数字，解析无法处理空格或任何其他分隔符...尝试将问题一分为二：解析和处理。解析问题可以通过不使用实际读取的值，而只是打印它们（或以某种形式存储，然后打印整个读取的表达式）来解决，这可以是第一步。确保解析器能够以稳健的方式处理常见表达式，如“1 2 +”、“10 20 +”、“1 2+”、“1 2 +”（注意空格的不同位置）。并且它无法优雅地解析“+”、“1 +”、“1 2 ++”等表达式...您永远不能信任用户输入，他们会犯错误，但这不应该使您的程序崩溃。

一旦确定能够解析输入，就开始实际的算法。使其对您之前可能无法处理的无效用户输入（例如“10 0 /”）具有鲁棒性，并进行实际处理。

学习使用调试器，它将帮助您了解事情出现问题时的原因是什么。调试器将花费不到一秒钟的时间来指出上面代码中的特定问题，它不会告诉您它为什么死掉，但它会向您显示它是如何死掉的以及程序的状态。如果我的预感是正确的，那么它会将您指出 operation.top() 指令作为罪魁祸首，并且您将能够看到您试图提取的元素多于插入的元素。逐步执行程序的一部分以了解它实际上在做什么，您会注意到，当您读取“12+”时，您实际上将两个看似无关的整数存储到堆栈中（'1的 ASCII 值） ' 和 '2'...