два стека

#include <iostream.h>
#include <stdlib.h>
#include <ctype.h> 
#include <vcl.h>
#pragma hdrstop
#include "stack.h"
#include "mathop.h"
//---------------------------------------------------------------------------
 
#pragma argsused
 
class MathOperator
{
private:
 
char op;
int inputprecedence;
int stackprecedence;
public:
MathOperator(void);
MathOperator(char ch);
int operators (MathOperator a) const;
void Evaluate (Stack<float> &OperandStack);
char GetOp(void);
};
 
MathOperator::MathOperator(char ch)
{
op = ch;
switch(op)
{
case '+' :
case '-': inputprecedence = 1;
stackprecedence = 1;
break;
case '*' :
case '/': inputprecedence = 2;
stackprecedence = 2;
break;
case '(' : inputprecedence = 3;
stackprecedence = -1;
break;
case ')' : inputprecedence = 0;
stackprecedence = 0;
break;
}
}
int MathOperator::operator (MathOperator a) const
{
return stackprecedence >= a.inputprecedence;
}
 void MathOperator::Evaluate (Stack<float> &OperandStack)
{
float operand1 = OperandStack.Pop(); 
float operand2 = OperandStack.Pop{); 
switch (op) // выбрать операцию
{
case '+' : OperandStack.Push(operand2 + operand1);
break;
case '-': OperandStack.Push(operand2 - operand1);
break;
case '*': OperandStack.Push(operand2 * operand1);
break;
case '/': OperandStack.Push(operand2 / operand1);
break;
}
}
 
 
int isoperator(char ch)
{
if (ch =='+' || ch == '-' || ch == '*' ||
ch == '/' || ch == '(')
return 1;
else
return 0;
}
 
int iswhitespace(char ch)
{
if (ch == ' ' || ch == '\t' || ch == '\n')
return 1;
else
return 0;
}
void error(int n)
{
static char *errormsgs[] = {
"Отсутствует оператор",
"Отсутствует операнд",
"Нет левой скобки",
"Нет правой скобки",
"Неверный ввод"
};
 
cerr << errormsgs[n]<< endl;
exit(1);
}
void main(void)
{
 
Stack<MathOperator> OperatorStack;
 
Stack<float> OperandStack;
MathOperator oprl,opr2;
int rank = 0;
float number;
char ch;
 
while (cin.get(ch) && ch != '=')
// ******** обработка операнда с плавающей точкой ********
if (isdigit(ch) || ch == '.' )
{
cin.putback(ch);
cin >> number;
 
rank++;
if (rank > 1)
error(OperatorExpected);
OperandStack.Push(number);
}
// ********* обработка оператора **********
else if (isoperator(ch))
{
 
if (ch !='(') // ранг ' (' равен 0
rank--;
if (rank < 0)
error(OperandExpected);
oprl = MathOperator(ch);
while(!OperatorStack.StackEmpty() && opr2 = OperatorStack.Peek() >= oprl)
{
opr2 = OperatorStack.Pop() ;
opr2.Evaluate(OperandStack);
}
OperatorStack.Push(oprl);
}
// ********* обработка правой скобки **********
else if (ch == rightparenthesis)
{
oprl = MathOperator(ch);
while(!OperatorStack.StackEmpty() && opr2 = OperatorStack.Peek() >= oprl)
{
opr2 = OperatorStack.Pop();
opr2.Evaluate(OperandStack);
}
if(OperatorStack.StackEmpty())
error(MissingLeftParenthesis);
opr2 = OperatorStack.Pop(); // get rid of ' ('
}
 
else if (liswhitespace(ch))
error(invalidlnput);
}
 
if (rank != 1)
error(OperandExpected);
 
while (!OperatorStack.StackEmpty())
{
oprl = OperatorStack.Pop();
if (oprl.GetOp()== leftparenthesis)
error(MissingRightParenthesis);
oprl.Evaluate(OperandStack);
}
 
cout << "Значение равно: " << OperandStack.Pop() << endl;
}
 
//---------------------------------------------------------------------------