调试后缀计算器

Question

我的任务是使用链表来表示堆栈，构建一个后缀计算器。我已经为计算器编写了以下代码，但我收到了一个我不理解的编译器错误。该错误来自postfixcalc.cpp文件，发生在operated2=opers.getTop（op）的if语句中。错误为"值未被忽略"。我正在使用Dev-C++，从未遇到过这种类型的消息。任何见解都将不胜感激。此外，如果需要，我可以提供StackP文件。

/** @file postfixcalc.h*/
#include "StackP.cpp"
#include <string>
using namespace std;
const int MAX_CHARS = 100;
class postfixcalc
{
public:
/** Default constructor. */
    postfixcalc();
// postfixcalc operations:
    void read();
    void show();
    int eval();
private:
    string e;
    Stack opers;
    char stringInput[MAX_CHARS];
    char *p;
};

/** @file postfixcalc.cpp*/
#include <iostream>
#include <cstring>
#include "postfixcalc.h"
using namespace std;
postfixcalc::postfixcalc()
{}
void postfixcalc::read()
{
    cout << "Please enter a postfix expression: ";
    getline(cin, e);
}//end read
void postfixcalc::show()
{
    cout << e << endl;
}//end show
int postfixcalc::eval()
{
    int operand1, operand2, result;
    int op;
    p = strtok(stringInput, " ");
    while(p)
    {
    op = p[0];
    if( op == '+' || op == '-' || op == '*' || op == '/')
    {
        operand2 = opers.getTop(op);
        opers.pop();
        operand1 = opers.getTop(op);
        opers.pop();
        switch(op)
        {
            case '+':
                    result = operand1 + operand2;
                    break;
            case '-':
                    result = operand1 - operand2;
                    break;
            case '*':
                    result = operand1 * operand2;
                    break;
            case '/':
                    result = operand1 / operand2;
                    break;
        }//end switch
        opers.push(result);
    }
    else
    {
        opers.push(op);
    }
    p = strtok(NULL, " ");
}//end while
}//end eval

以下是StackP 的实现

/** @file StackP.h */
#include "StackException.h"
typedef int StackItemType;
/** ADT stack - Pointer-based implementation. */
class Stack
{
public:
// Constructors and destructor:
   /** Default constructor. */
   Stack();
   /** Copy constructor.
    * @param aStack The stack to copy. */
   Stack(const Stack& aStack);
   /** Destructor. */
   ~Stack();
// Stack operations:
   bool isEmpty() const;
   void push(const StackItemType& newItem) throw(StackException);
   void pop() throw(StackException);
   void pop(StackItemType& stackTop) throw(StackException);
   void getTop(StackItemType& stackTop) const
      throw(StackException);
private:
   /** A node on the stack. */
   struct StackNode
   {
      /** A data item on the stack. */
      StackItemType item;
      /** Pointer to next node.     */
      StackNode    *next;
   }; // end StackNode
   /** Pointer to first node in the stack. */
   StackNode *topPtr;
}; // end Stack
/** @file StackP.cpp */
#include <cstddef>   // for NULL
#include <new>       // for bad_alloc
#include "StackP.h"  // header file
using namespace std;
Stack::Stack() : topPtr(NULL)
{
}  // end default constructor
Stack::Stack(const Stack& aStack)
{
   if (aStack.topPtr == NULL)
      topPtr = NULL;  // original list is empty
   else
   {  // copy first node
      topPtr = new StackNode;
      topPtr->item = aStack.topPtr->item;
      // copy rest of list
      StackNode *newPtr = topPtr;    // new list pointer
      for (StackNode *origPtr = aStack.topPtr->next;
       origPtr != NULL; origPtr = origPtr->next)
      {  newPtr->next = new StackNode;
         newPtr = newPtr->next;
     newPtr->item = origPtr->item;
      }  // end for
      newPtr->next = NULL;
   }  // end if
}  // end copy constructor
Stack::~Stack()
{
   // pop until stack is empty
   while (!isEmpty())
      pop();
   // Assertion: topPtr == NULL
}  // end destructor
bool Stack::isEmpty() const
{
   return topPtr == NULL;
}  // end isEmpty
void Stack::push(const StackItemType& newItem)
        throw(StackException)
{
   // create a new node
   try
   {
      StackNode *newPtr = new StackNode;
      // set data portion  of new node
      newPtr->item = newItem;
      // insert the new node
      newPtr->next = topPtr;
      topPtr = newPtr;
   }
   catch (bad_alloc e)
   {
      throw StackException(
     "StackException: push cannot allocate memory.");
   }  // try
}  // end push
void Stack::pop() throw(StackException)
{
   if (isEmpty())
      throw StackException("StackException: stack empty on pop");
   else
   {  // stack is not empty; delete top
      StackNode *temp = topPtr;
      topPtr = topPtr->next;
      // return deleted node to system
      temp->next = NULL;  // safeguard
      delete temp;
   }  // end if
}  // end pop
void Stack::pop(StackItemType& stackTop) throw(StackException)
{
   if (isEmpty())
     throw StackException("StackException: stack empty on pop");
   else
   {  // stack is not empty; retrieve and delete top
      stackTop = topPtr->item;
      StackNode *temp = topPtr;
      topPtr = topPtr->next;
      // return deleted node to system
      temp->next = NULL;  // safeguard
      delete temp;
   }  // end if
}  // end pop
void Stack::getTop(StackItemType& stackTop) const throw(StackException)
{
   if (isEmpty())
      throw StackException("StackException: stack empty on getTop");
   else
      // stack is not empty; retrieve top
      stackTop = topPtr->item;
}  // end getTop

这是编译器错误：

C： \文档和设置\所有者\我的。。。在成员函数"int postfixcalc:：eval（）"中：

35 C:\Documents and Settings\所有者。。。无效值未被忽略，因为它应该是

37 C:\Documents and Settings\所有者。。。void值没有被忽略，因为它应该是

Answer 1

void Stack::getTop(StackItemType& stackTop) const throw(StackException)
int postfixcalc::eval()
{
int operand1, operand2, result;
    operand2 = opers.getTop(op);

getTop函数不返回任何内容，然后不返回任何信息并将其存储在int中。我想你想要更像这样的东西：

   opers.getTop(operand2); 

Answer 2

Stack::getTop()是这样声明的：

void getTop(StackItemType& stackTop);

void表示函数不返回值。因此，尝试将调用opers.getTop()的结果分配给operand2是不可能的，因为getTop()不返回任何内容！getTop()采用引用参数，因此它可以将最高值直接分配给您传递的变量：

opers.getTop(operand2);

您可以直接使用std::stack:，而不是编写自己的Stack类

#include <stack>
#include <iostream>
int main(int argc, char** argv) {
    std::stack<int> stack;
    stack.push(3);
    std::cout << stack.top() << 'n';
    stack.pop();
}

……当然，除非这是一个学习练习，在这种情况下，只需为未来提交小费。一旦你知道某件事是如何完成的，你就应该利用其他人已经以可重复使用的方式为你完成了这项工作的事实。