算术表达式求值不能正确求值？（输入表达式，以#结束，无法得到结果）

[twlkyao]

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#define STINSI_OPTR 100//操作符OPTR的初始空间大小
#define STINSI_OPND 100//操作数OPND的初始空间大小
#define STINNT_OPTR 10//操作符OPTR的存储空间增量
#define STINNT_OPND 10//操作数OPND的存储空间增量
using namespace std;
typedef struct //定义操作符OPTR栈的结构
{char *base;
char *top;
int stacksize;
}OPTRST;

typedef struct //定义操作数OPND栈的结构
{int *base;
int *top;
int stacksize;
}OPNDST;

void INIT_OPTR(OPTRST &s)//初始化操作符栈
{s.base=(char *)malloc(STINSI_OPTR*sizeof(OPTRST));
if(!s.base) exit(-1);//存储分配失败
s.top=s.base;
s.stacksize=STINSI_OPTR;
}//初始化OPTRST栈

char OPTR_PUSH(OPTRST &s,char e)//向操作符栈中压入元素
{if(s.top-s.base>=s.stacksize){
s.base=(char *)realloc(s.base,(s.stacksize+STINNT_OPTR)*sizeof(OPTRST));
if(!s.base) exit(-1);
s.top=s.base+s.stacksize;
s.stacksize+=STINNT_OPTR;
} //栈满追加空间 //realloc 和malloc 前面的类型
*s.top=e;
s.top++;
//printf("The OPTR has the data:%c\n",*(s.top-1));//打印push入操作符OPTR栈元素
return e;
}

char OPTR_POP(OPTRST &s,char &e)//操作符栈顶元素出栈
{if(s.top==s.base)exit(-1);//判栈空
s.top--;
e=*s.top;
//printf("The OPTR has poped the data:%c\n",e);//打印pop出操作符OPTR栈元素
return e;
}

void INIT_OPND(OPNDST &s)//初始化操作数栈
{s.base=(int *)malloc(STINSI_OPND*sizeof(OPNDST));
if(!s.base) exit(-1);//存储分配失败
s.top=s.base;
s.stacksize=STINSI_OPND;
}

int OPND_PUSH(OPNDST &s,int e)//向操作数栈中压入元素
{if(s.top-s.base>=s.stacksize){
s.base=(int *)realloc(s.base,(s.stacksize+STINNT_OPND)*sizeof(OPNDST));
if(!s.base) exit(-1);
s.top=s.base+s.stacksize;
s.stacksize+=STINNT_OPND;
}//栈满追加空间 //realloc和malloc前面的类型
*s.top=e;
s.top++;
// printf("The OPND has the data:%d\n",*(s.top-1)); //打印push入操作数OPND栈元素
return e;
}

int OPND_POP(OPNDST &s,int &e)//操作数栈顶元素出栈
{if(s.top==s.base)exit(-1);//判栈空
s.top--;
e=*s.top;
//printf("The OPND has poped the data:%d\n",e);//打印pop出操作数OPND栈元素
return e;
}

char Precede [7][7]=//优先级数组
{
{'>','>','<','<','<','>','>'},
{'>','>','<','<','<','>','>'},
{'>','>','>','>','<','>','>'},
{'>','>','>','>','<','>','>'},
{'<','<','<','<','<','=','\0'},
{'>','>','>','>','\0','>','>'},
{'<','<','<','<','<','\0','='}
};

char OPTR_GT(OPTRST &s)//取操作符栈OPTR栈顶元素
{if(s.top==s.base) exit(-1);//判栈空
s.top--;
return *(s.top);
}

int OPND_GT(OPNDST &s)//取操作数栈OPND栈顶元素
{if(s.top==s.base) exit(-1);//判栈空
s.top--;
return *(s.top);
}

int char_to_int(char c)//将符号的优先级变为数组存储
{ switch(c)
{
case'+':return 0;
case'-':return 1;
case'*':return 2;
case'/':return 3;
case'(':return 4;
case')':return 5;
case'#':return 6;
default:return 7;
}
}

char Feedback(OPTRST s,char c)//判断优先级并返回优先级二维数组
{int m,n;
m=char_to_int(*(s.top-1));
n=char_to_int(c);
return Precede[m][n];
}

int Operate(int a,char theta,int b)//计算时要考虑分母为零（在主函数中）
{switch(theta)
{case'+':return a+b;
case'-':return a-b;
case'*':return a*b;
case'/':return a/b;
default:return -1;
}
}

int main()
{ OPTRST OPTR;
OPNDST OPND;
INIT_OPTR(OPTR);//初始化
INIT_OPND(OPND);//初始化
OPTR_PUSH(OPTR,'#');//向操作符OPTR栈中压入优先级最低的操作符
int N=0,a,b;//N在while中变化？
char c,theta;
cout<<"Please input the expression(end by '#')!"<<"\n";
c=getchar();
while(c!='#'||OPTR_GT(OPTR)!='#')
{
if(c>=48 && c<=57)
{while(c>=48 && c<=57)
{N=10*N+c-'0';
c=getchar();
}
OPND_PUSH(OPND,N);
printf("The OPND has the data:%d\n",N);
N=0;
}
else
switch(Feedback(OPTR,c))
{case'<':OPTR_PUSH(OPTR,c);
printf("The OPTR has the data:%c\n",c);
c=getchar();break;
case'=':OPTR_POP(OPTR,theta);
printf("The OPTR has popped the data:%c\n",theta);
c=getchar();break;
case'>':OPTR_POP(OPTR,theta);
OPND_POP(OPND,b);
printf("The OPND has popped the data:%d\n",b);
OPND_POP(OPND,a);
printf("The OPND has popped the data:%d\n",a);
/*if(b==0 && theta=='/')
{printf("You have input the wrong expression!");
exit(-1);
}*/
cout<<"The operation is:"<<a<<theta<<b<<"\n";
OPND_PUSH(OPND,Operate(a,theta,b));
printf("The OPND has the data:%d\n",Operate(a,theta,b));break;
}
}
//最后得到'#'是有问题


cout<<"The result is:"<<OPND_GT(OPND)<<"\n";//输出最后结果
return 0;
}