C++ 中的逆波兰表示法

Question

我目前正在尝试为作业编写 RPN 计算器，但遇到了一些问题。方法 evaluateCountdown 用于接收包含用逆波兰表示法编写的数学表达式的字符串，并将计算表达式的结果作为双精度值返回。

例如：字符串“3.0 4.0 + 2.0 *”应该以双精度形式返回 14.0。

#include <string>
#include <sstream>
#include <vector>
#include <iterator>
#include <stack>
 
class CountdownSolution {

std::vector<std::string> stringToVector(const std::string newString,const char token)
{
 std::vector<std::string> stringVector;
 
 size_t posLast = 0, pos = 0;
 while((pos = newString.find(token, pos)) != std::string::npos)
 {
   if(newString[pos] != newString[posLast])
     stringVector.push_back(newString.substr(posLast, pos - posLast));
   posLast = ++pos;
 }
 if(newString[posLast] != 0)
   stringVector.push_back(newString.substr(posLast));
 
 return stringVector;
}
 
double evaluateCountdown(const std::string& rpnString) {
   std::vector<std::string> rpnStringVector = stringToVector(rpnString,' ');
   std::stack<double> rpnStack;
   int i = 0;
   double temp;
   for (std::vector<std::string>::iterator t=rpnStringVector.begin(); t!=rpnStringVector.end(); ++t)
   {
       if(rpnStringVector[i] == "+"){
           temp = std::stod(rpnStringVector[i-2])+std::stod(rpnStringVector[i-1]);
           rpnStack.pop();
           rpnStack.pop();
           rpnStack.push(temp);
           i++;
           continue;
       } else if(rpnStringVector[i] == "-"){
           temp = std::stod(rpnStringVector[i-2])-std::stod(rpnStringVector[i-1]);
           rpnStack.pop();
           rpnStack.pop();
           rpnStack.push(temp);
           i++;
           continue;
       } else if(rpnStringVector[i] == "*"){
           temp = std::stod(rpnStringVector[i-2])*std::stod(rpnStringVector[i-1]);
           rpnStack.pop();
           rpnStack.pop();
           rpnStack.push(temp);
           i++;
           continue;
       } else if(rpnStringVector[i] == "/"){
           temp = std::stod(rpnStringVector[i-2])/std::stod(rpnStringVector[i-1]);
           rpnStack.pop();
           rpnStack.pop();
           rpnStack.push(temp);
           i++;
           continue;
       } else {
           rpnStack.push(std::stod(rpnStringVector[i]));
           i++;
           continue;
       }
   }
   return rpnStack.top();
   }
}

在以下 4 次测试中，我只通过了 1 次。

#include <iostream>
using std::cout;
using std::endl;
 
#include <string>
 
int main() {
 
   int retval = 0;
  
   {
       double answer = evaluateCountdown(std::string("3.0 4.0 +"));
       if (answer == 7.0) {
           cout << "1) Pass: evaluated '3.0 4.0 +', got 7.0\n";
       } else {
           cout << "1) Fail: evaluated '3.0 4.0 +' expecting 7.0, but got " << answer << std::endl;
           ++retval;
       }
   }
  
   {
       double answer = evaluateCountdown(std::string("3.0 4.0 - 4.0 +"));
       if (answer == 3.0) {
           cout << "2) Pass: evaluated '3.0 4.0 - 4.0 +', got 3.0\n";
       } else {
           cout << "2) Fail: evaluated '3.0 4.0 - 4.0 +' expecting 3.0, but got " << answer << std::endl;
           ++retval;
       }
   }
  
   {
       double answer = evaluateCountdown(std::string("3.0 4.0 - 2.0 *"));
       if (answer == -2.0) {
           cout << "3) Pass: evaluated '3.0 4.0 - 2.0 *', got -2.0\n";
       } else {
           cout << "3) Fail: evaluated '3.0 4.0 - 2.0 *' expecting -2.0, but got " << answer << std::endl;
           ++retval;
       }
   }
      
 
   {
       double answer = evaluateCountdown(std::string("100 20 / 4 +"));
       if (answer == 9) {
           cout << "4) Pass: evaluated '100 20 / 4 +', got 9\n";
       } else {
           cout << "4) Fail: evaluated '100 20 / 4 +' expecting 9, but got " << answer << std::endl;
           ++retval;
       }
   }
 
   return retval;
}

这是我运行测试的输出。

1. 通过：评估为 '3.0 4.0 +'，获得 7.0
2. 失败：评估 '3.0 4.0 - 4.0 +' 期望 3.0，但得到 -1
3. 失败：评估 '3.0 4.0 - 2.0 *' 期望 -2.0，但得到 -1
4. 失败：评估 '100 20 / 4 +' 期望 9，但得到 5

我可以从我的结果中看到 for 循环只遍历向量的前 3 个元素，但我不知道为什么。

Answer 1

拆分字符串按预期工作，问题是您错误地管理堆栈上的值。而不是尝试重新读取（并重新解析！）来自字符串向量的值（在最坏的情况下，这可能导致将运算符评估为双精度，从而导致异常），您应该从堆栈，应用运算符并将结果推回，如下：

double o2 = rpnStack.top();
rpnStack.pop();
double o1 = rpnStack.top();
rpnStack.pop();
rpnStack.push(o1 <op> o2);

此时重要的是：由于这是一个堆栈，因此您首先推送第一个操作数，最后推送第二个操作数，因此您也需要以相反的顺序弹出！

关于您的代码的其他一些问题：

1. 浮点值不允许进行精确的数学运算，即使是像 0.1 这样简单的值也无法准确地表示为二进制的周期性，因此所有浮点数学都可能存在舍入问题 - 结果是 cannot compare for exact (in-) equality。李>
2. 如果您没有任何要跳过的内容，则不需要所有这些 continues - 无论如何，任何后续代码都包含在 else 中。
3. main 中所有不必要的大括号使代码阅读起来非常不便，您应该删除它们。当然，answer 将被多次定义，但这可以通过简单地在后续调用 (double a = e(); a = e();) 中删除声明来解决。
4. 应用上述更改，您可以使用基于范围的循环来简化循环：
   for(auto& s : rpnStringVector) 并在循环主体内评估 s（如果您愿意，可以给它取另一个名字...）而不是 @987654330 @。

您似乎打算将函数作为类的成员 (class CountdownSolution {)，实际上是无效代码，因为您从不关闭此类 - 您可以避免重复代码并通过避免复制来提高效率：

class CountdownSolution
{
public:
    // use std::string_view so that we can operate
    // without partial copies (sub-strings!) entirely:
    double evaluate(std::string_view const& expression)
    {
        size_t posLast = 0;
        size_t pos = 0;
        while((pos = expression.find(' ', pos)) != std::string::npos)
        {
            if(expression[pos] != expression[posLast])
            {
                // evaluate immediately instead of adding to function
                doEvaluate(expression.substr(posLast, pos - posLast));
            }
            posLast = ++pos;
        }
        if(expression[posLast] != 0)
        {
            doEvaluate(expression.substr(posLast));
            posLast = ++pos;
        }
        auto result = m_stack.top();
        // clear the stack so that we can re-use the instance!
        m_stack.pop();
        return result;
    }

private:
    std::stack<double> m_stack; // make the stack a member!

    void doEvaluate(std::string_view const& token)
    {
        if(token == "+")
        {
            // structured binding - need C++17 for
            // unpacks the pair being returned to op1 and op2
            auto [op1, op2] = popOperands();
            m_stack.push(op1 + op2);
        }
        else if(token == "-")
        {
            auto [op1, op2] = popOperands();
            m_stack.push(op1 - op2);
        }
        else if(token == "*")
        {
            auto [op1, op2] = popOperands();
            m_stack.push(op1 * op2);
        }
        else if(token == "/")
        {
            auto [op1, op2] = popOperands();
            m_stack.push(op1 / op2);
        }
        else
        {
            // as using std::string_view, we cannot use std::stod
            auto end = &token.back() + 1;
            double tmp;
            // from charconv header:
            auto [last, ec] = std::from_chars(&token.front(), end, tmp);
            if(ec != std::errc() || last != end)
            {
                // invalid string!
                // best: throw an exception!

                // but assure an empty stack before so that we
                // can re-use the instance!
                // too bad there's no `clear` for...
                m_stack = std::stack<double>();

                // SHOULDN'T throw THAT but too lazy to
                // select the appropriate exceptions...
                // leaving this to you!
                // (use different ones for different errors, see
                // https://en.cppreference.com/w/cpp/utility/from_chars)
                throw ec;
            }
            m_stack.push(tmp);
        }
    }

    std::pair<double, double> popOperands()
    {
        std::pair<double, double> result;
        // as explained already: need to pop second operand first!
        result.second = m_stack.top();
        m_stack.pop();
        result.first = m_stack.top();
        m_stack.pop();
        return result;
    }
};

承认，必须使用std::from_chars 太好了...如果您不喜欢，可以将std::string_views 恢复为std::strings（仍然是所有const 引用），使用@987654337 @ 再次。然后，您再次复制子字符串，但一次只复制一个（并且您保留了向量）。但是该函数可能会抛出，并且您可能仍然会在之后保持您的类可重用，所以您应该这样做：

try
{
    m_stack.push(std::stod(token));
}
catch(...) // as we are re-throwing anyway we can catch unspecifically
{
    // clearing the stack again
    // that might fail on std::bad_alloc, but then we're out anyway... 
    m_stack = std::stack<double>();

    // just re-throw:
    throw;
}

最终建议：不要只是复制粘贴，你不会从中学到任何东西（但如果你这样做，不是我的问题......），试着理解，然后自己重​​写。如果有不清楚的地方，请随时发表评论；）