1

我的任务是构建一个使用链表来表示堆栈的后缀计算器。我已经为计算器编写了以下代码，但是我收到了一个我不理解的编译器错误。该错误来自 postfixcalc.cpp 文件，并且发生在操作数 2 = 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:\Documents and Settings\Owner\My... 在成员函数 `int postfixcalc::eval()' 中：

35 C:\Documents and Settings\Owner... void 值没有被忽略，因为它应该被忽略

37 C:\Documents and Settings\Owner... void 值没有被忽略，因为它应该被忽略

4

2 回答 2

1

Stack::getTop()声明如下：

void getTop(StackItemType& stackTop);

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

opers.getTop(operand2);

而不是编写自己的Stack课程，您可以使用std::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();
}

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

于 2012-03-27T17:15:32.810 回答
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);
于 2012-03-27T17:16:12.427 回答