数据结构中中缀表达式转化为后缀表达式，并计算表达式的值，下面是我的代码，可是程序运行不了，调试的时候看不出来问题在哪啊，求神人帮忙啊

[lmBLCU]

.h文件内容：template <class E>
class Stack
{
public:
//如果是抽象基类，不需要写构造函数
virtual void Push(E x)=0; //进栈
virtual E Pop()=0; //出栈
virtual E getTop() const=0; //取栈顶
virtual bool IsEmpty() const=0; //判栈空
virtual bool IsFull() const=0; //判栈满

};
template <class E>
class SeqStack:public Stack<E>
{
//顺序栈类定义
private:
E* elements; //栈元素存放数组
int top; //栈顶指针
int maxSize; //栈最大容量
void overflowProcess(); //栈的溢出才处理
public:
SeqStack(int sz=50); //构造函数
~SeqStack(){delete []elements;} //析构函数
void Push(E x); //进栈
E Pop(); //出栈
E getTop() const; //取栈顶
bool IsEmpty() const
{
if(top==-1)
return true; //判空
else
return false;
}

bool IsFull() const
{
if(top==maxSize-1)
return true; //判满
else
return false;
}
friend ostream & operator<<(ostream& out,const SeqStack<E>& X);

};
template<class E>
SeqStack<E>::SeqStack(int sz):top(-1),maxSize(sz)
{
elements=new E[maxSize]; //创建栈的数据空间
assert(elements!=NULL); //断言：动态存储分配是否成功

}
template<class E>
void SeqStack<E>::overflowProcess()
{
//私有函数：当栈满就执行扩充栈存储空间处理
E* newArray=new E[2*maxSize];
maxSize+=maxSize;
for(int i=0;i<=top;i++)
{
newArray[i]=elements[i];
}
delete []elements;
elements=newArray; //改变elements指针,指向newArray
}
template<class E>
void SeqStack<E>::Push(E x)
{
//若栈不满，则将元素x插入栈顶，否则溢出处理
if (IsFull()==true)
overflowProcess();
elements[++top]=x; //指针先加1，再进栈

}
template<class E>
E SeqStack<E>::Pop()
{
//函数退出栈顶元素并返回栈顶元素的值
if(IsEmpty()==true)
return -1;
return elements[top--];

}
template<class E>
E SeqStack<E>::getTop() const
{
//公共函数：若栈不空则返回该栈栈顶元素的地址
if(IsEmpty()==true)
return -1;

return elements[top];
}
template<class E>
ostream& operator<<(ostream& out,const SeqStack<E>& x)
{
out<<x.top<<endl;
for (int i=0;i<=x.top;i++)
{
out<<x.elements[i]<<endl;
}
return out;
}
.cpp文件中：
int isp[]={0,1,5,3,6};
int icp[]={0,6,4,2,1};
bool isdigict(char c)
{
if (1<'c'<9)
return true;
else
return false;
}

int getisp(char c)
{
switch(c)
{
case'+':
return isp[3];
case'-':
return isp[3];
case'*':
return isp[2];
case'/':
return isp[2];
case'%':
return isp[2];
case'=':
return isp[0];
default:
return -1;
}
}
int geticp(char c)
{
switch(c)
{
case'+':
return isp[3];
case'-':
return isp[3];
case'*':
return isp[2];
case'/':
return isp[2];
case'%':
return isp[2];
case'=':
return isp[0];
default:
return -1;
}
}
int operate(int x,char k,int y)
{
int end;
switch (k)
{
case'+':
end=x+y;
break;
case'-':
end=x-y;
break;
case'*':
end=x*y;
break;
case'/':
end=x/y;
break;
}
return end;
}
void transform(char *s)
{
int operate(int x,char k,int y);
int getisp(char);
int geticp(char);
SeqStack<char> optr; //运算符堆栈operator
SeqStack<int> opnd; //运算数堆栈operand
int i; //扫描下标
while (1)
{
if (s[i]=='='&&optr.IsEmpty())
{
break;
}
if (isdigict(s[i]))
{
cout<<s[i];
opnd.Push(s[i]-48);
}
else
{

if (optr.IsEmpty())
{
optr.Push(s[i]);
}
else
{
int w; //栈外优先级
w=geticp(s[i]);
char t=optr.getTop();
int l ; //栈顶优先级
l=getisp(s[i]);
if (w>l)
{
optr.Push(s[i]);
}
else
{
char c=optr.Pop();
int a=opnd.Pop();
int b=opnd.Pop();

opnd.Push(operate(b,c,a));
i--;
cout<<t;

}
}
}
i++;
}
cout<<opnd.getTop();


}void main()
{
char s[10];
for (int i=0;i<10;i++)
{
cin>>s[i];
if(s[i]=='=')
break;
}


transform(s);


}