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

编辑：： 我已经对我的程序进行了更改。看看calc.cpp。特别是等运算符函数和第四个while循环

我认为问题在于char op没有设置为“/”。当我回到等运算符函数时

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

到

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

Dstack.h（堆栈类）：

#ifndef DSTACK#H
#定义DSTACK_H
#包括
类数据堆栈
{
公众：
Dstack（）；
~Dstack（）；
无效推力（双值）；
bool pop（双倍值）；
双头（）；
int size（）；
bool empty（）；
bool print（）；
私人：
类节点
{
公众：
节点（双值，节点*下一个）
{m_value=value；m_next=next；}
双m_值；
Node*m_next；
};
节点*m_头；
};
#恩迪夫

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

#包括“dstack.h”
#包括
Dstack:：Dstack（）
{
m_头=空；
}
void Dstack:：push（双值）
{
m_头=新节点（值，m_头）；
}
booldstack:：pop（双倍值（&value）
{
如果（m_head==NULL）
返回false；
值=m_头->m_值；
节点*温度=m_头；
m_head=m_head->m_next；
删除临时文件；
返回true；
}
double-Dstack:：top（）
{
双值=m_头->m_值；
返回值；
}         
int-Dstack:：size（）
{
整数计数=0；
节点*ptr=m_头；
while（ptr！=NULL）
{
计数++；
ptr=ptr->m_next；
}
返回计数；
}   
booldstack:：empty（）
{
如果（m_head==NULL）
返回true；
返回false；
}
Dstack:：~Dstack（）
{
节点*ptr=m_头；
while（ptr！=NULL）
{
节点*temp=ptr；
ptr=ptr->m_next；
删除临时文件；
} 
}
booldstack:：print（）
{
//如果（m_head->m_next==NULL）
//返回false；
标准：：cout m_值>标准：：ws；
while（isdigit（std:：cin.peek（））
{     
std:：cin>>num；
stack.push（num）；
while（isspace（std:：cin.peek（））
{   
std:：cin.ignore（）；
std:：cin.peek（）；
}   
}   
while（等运算符（std:：cin.peek（））
{
//确保有多个操作数要计算
如果（stack.size（）解决您的问题，我建议您对输入处理进行全面重构

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

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


对于，只需丢弃角色并继续下一个
如果它是一个数字，则在它是一个数字时提取字符，并根据该数字构造数字
如果它是一个有效的操作符，那么处理它
如果是其他错误，则处理错误（例如跳过当前行并读取下一行）

正如您所看到的，输入的一种错误处理是上述方法中内置的

还可以很容易地扩展上述内容，以识别可用于变量或函数的符号


主循环在代码中可能类似于以下内容：

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]
    }
}

while（std:：getline（std:：cin，line））
{
对于（大小为当前字符索引=0；当前字符索引

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

最后，除非你的练习是关于创建自己的堆栈类，否则首先使用。
这不是一个。请，我也推荐。@Someprogrammerdude谢谢你告诉我正确的例子。我一直在努力，现在有一个更具体的问题。
char ops[] = {'^','-','+','*','/'};

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

#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 

#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;
}

#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;
}

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]
    }
}