我的任务是使用链表建立一个后缀计算器来表示堆栈。我已经为计算器编写了以下代码，但是我收到了一个我不理解的编译器错误。该错误来自postfixcalc.cpp文件，发生在operand2 = 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 value不应该被忽略，因为它应该是
37 C：\ Documents and Settings \ Owner ... void value不应该被忽略，因为它应该是
答案 0 :(得分：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();
}
......除非当然这是一次学习练习，在这种情况下，只需提出未来的提示。一旦你知道某些事情是如何完成的，你应该利用其他人已经以可重用的方式为你完成工作的事实。
答案 1 :(得分：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);