RPN 计算器 c++ 错误处理和多个运算符

Question

编辑:: 我对我的程序进行了更改。看看 calc.cpp。特别是 isOperator 函数，以及第四个 while 循环——即

while (isOperator(std::cin.peek()))
...
   ...
   if ( op == '/')

我认为问题在于 char op 未设置为“/”。当我回到我的 isOperator 函数时

int isOperator(char ch)
{
   int count = 0;
   char ops[] = {'-','+','*','/', '^'};
   for (int i = 0; i < 4; i++)
   {   
       if (ch == ops[i])
          count++;
   }
   return count;
}

改变

char ops[] = {'^','-','+','*','/'};

到

char ops[] = {'-','+','*','/', '^'};

op 可以设置为'/'，但不能设置为'^'。一定有一些我没有看到的简单的东西。

Dstack.h（堆栈类）：

#ifndef DSTACK_H
#define DSTACK_H

#include <iostream>

class Dstack
{
   public:
      Dstack();
      ~Dstack();
      void push(double value);
      bool pop(double &value);
      double top();
      int size();
      bool empty();
      bool print();
  private:
      class Node
      {
         public:
            Node(double value, Node* next)
            {m_value = value; m_next = next;}
            double m_value;
            Node* m_next;
     };
     Node* m_head;
 };


#endif 

Dstack.cpp（堆栈函数定义）：

#include "dstack.h"
#include <iostream>

Dstack::Dstack()
{
   m_head = NULL;
}

void Dstack::push(double value)
{
   m_head = new Node (value, m_head);
}

bool Dstack::pop(double &value)
{
   if (m_head == NULL)
   return false;

   value = m_head->m_value;
   Node *temp = m_head;
   m_head = m_head->m_next;
   delete temp;
   return true;
}

double Dstack::top()
{
   double value = m_head->m_value;
   return value;
}         

int Dstack::size()
{
  int count = 0;
  Node *ptr = m_head;
  while (ptr != NULL)
  {
     count++; 
     ptr = ptr->m_next;
  }
  return count;
}   

bool Dstack::empty()
{
   if (m_head == NULL)
   return true;

   return false;
}

Dstack::~Dstack()
{
   Node* ptr = m_head;
   while (ptr != NULL)
   {
      Node* temp = ptr;
      ptr = ptr->m_next;
      delete temp;
   } 
}

bool Dstack::print()
{
   //if (m_head->m_next == NULL)
   //return false;

   std::cout << m_head->m_value << std::endl;
   return true;
}

Calc.cpp（计算器函数）

#include "dstack.h"
#include <iostream>
#include <sstream>
#include <string>
#include <cmath>
#include <sstream> 

int isOperator(char ch) 
{ 
   int count = 0;  
   char ops[] = {'-','+','*','^','/'};
   for (int i = 0; i < 4; i++) 
   {   
      if (ch == ops[i])
      count++;
   }   
   return count;
}


int main()
{ 
   Dstack stack;
   double num;
   double result = 0;
   char op = '\0';
   double a = 0;
   double b = 0;


   while (std::cin.peek() != EOF)
   {   
      std::cin >> std::ws;
      while (isdigit(std::cin.peek()))
      {     
         std::cin >> num;
         stack.push(num);

         while(isspace (std::cin.peek()))
         {   
            std::cin.ignore();
            std::cin.peek();
         }   
     }   

     while (isOperator(std::cin.peek())) 
     {

        //make sure there is more than one operand to calculate
        if (stack.size() <2)
        {
           std::cerr << "Error: Invalid Expression." << std::endl;
           exit(1);
        }

        //make sure there are enough operators
        if (isOperator(std::cin.peek() +1 < stack.size() ))
        {
           std::cerr << "Error: Invalid Expression." << std::endl;
           exit(1);
        }

        //clear white space for each cycle
        std::cin >> std::ws; 

        //operate!
        std::cin >> op;
        if (op == '+')
        {

           b = stack.top();
           stack.pop(b);
           a = stack.top();
           stack.pop(a);
           result = a + b;
           stack.push(result);
       }
       if (op == '-')
       {
           b = stack.top();
           stack.pop(b);
           a = stack.top();
           stack.pop(a);
           result = a - b;
           stack.push(result);
       }
       if (op == '*')
       {
           b = stack.top();
           stack.pop(b);
           a = stack.top();
           stack.pop(a);
           result = a * b;
           stack.push(result);
       }
        if (op == '^')
       {
          b = stack.top();
          stack.pop(b);
          a = stack.top();
          stack.pop(a);

          result = pow(a,b);
          stack.push(result);
      }
       if (op == '/')
        {
           b = stack.top();
           stack.pop(b);
           a = stack.top();
           stack.pop(a);

           //b cant equal 0!!!
           if (b == 0)
           {
              std::cerr << "Error: Invalid expression." << std::endl;
              exit(1);
           }
           result = a / b;
           stack.push(result);
        }

        std::cout << op << std::endl;

        //move char to next position    
        std::cin.peek();

        //ignore possible white spaces left in expression and repeat
        while (isspace (std::cin.peek()))
        {
           std::cin.ignore();
           std::cin.peek();
        }
     }
}
   if (stack.size() == 1)
      std::cout << result << std::endl;
   else
   {
      std::cerr << "Error: Invalid expression." << std::endl;
      exit(1);
   }

   return 0;
}

Answer 1

对于您的问题，我建议您对输入处理进行全面重构。

首先到read whole lines，然后逐个字符地解析输入行。这样实际上更容易识别和处理各种运算符。

例如：从输入行中获取下一个字符，并检查它是什么类型的字符：

• 对于white-space，只需丢弃字符并继续下一个
• 如果是 digit，则在它是数字时获取字符并从中构造数字
• 如果它是一个有效的运算符，则处理它
• 如果是其他问题，则处理错误（例如，跳过当前行并阅读下一行）

如您所见，输入的一种错误处理是内置于上述方法中的。

上面的扩展也很容易识别符号，可用于变量或函数。

---

主循环在代码中可能如下所示：

while (std::getline(std::cin, line))
{
    for (size_t current_char_index = 0; current_char_index < line-size(); ++current_char_index)
    {
        // TODO: Handle current character at line[current_char_index]
    }
}

为了实用，我还建议将主代码拆分为函数。

最后，除非您的练习是关于制作自己的堆栈类，否则请使用std::stack。