题目原型： 四则运算器：实现多位整数的带括号的四则运算

现存问题：

1.以下代码利用两个char类型的栈分别存取运算数和运算符，但在结束一次优先级高运算后（考虑到运算精度问题，故在程序中，将每次运算的结果都保存为double型）可能会出现浮点值，这个值必须要压栈，并于下一个优先级产生运算，但这个浮点型值无法压入char型栈中，必须要一位一位存取才可实现，请问有没有比较好的办法解决这个问题，应该怎样将数据压入栈中？

2.程序中出现如图所示错误，麻烦大佬指点一下原因!

 #include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define Stack_Size 50

typedef char StackElementType; 
typedef struct
{
    StackElementType elem[Stack_Size];
    int Top;
}SeqStack; 

void InitStack(SeqStack *S);
int Push(SeqStack *S,StackElementType x);
int Pop(SeqStack *S,StackElementType *x);
int GetTop(SeqStack *S,StackElementType *x);
StackElementType Compare(StackElementType ch1,StackElementType ch2);
StackElementType Execute(StackElementType a,StackElementType op,StackElementType b);

int main()
{
    printf("%c",ExpEvaluation()); 
    return(0);
}
StackElementType ExpEvaluation()
{
    SeqStack OPTR,OVS;
    StackElementType n;
    StackElementType a,b,ch,op,x,v;
    InitStack(&OPTR);
    InitStack(&OVS);
    Push(&OPTR,'#');
    printf("Please input an expression(Ending with #):");
    ch=getchar();//为方便，所以数字也以字符形式来存储 
    while(ch!='#'||GetTop(&OPTR,&x)!='#')
    {
        if(ch>='0'&&ch<='9')//不是操作符，是操作数，进OVS栈 
        {
            int temp;
            temp=ch-'0';//先把当前操作数从字符变为数字 
            ch=getchar();
            while(ch>='0'&&ch<='9')//继续判断下一位是否为操作数
            {
                temp=temp*10+ch-'0';
                ch=getchar();
            } 
            Push(&OVS,temp);

        }
        else
        switch(Compare(ch,GetTop(&OPTR,&x)))
        {
            case '>':Push(&OPTR,ch);
              scanf("%d",&ch);
            case '=':Pop(&OPTR,&op);ch=getchar();break;//脱括号 
            case '<':Pop(&OPTR,&op);//形成运算 
            Pop(&OVS,&b);
            Pop(&OVS,&a);
            v=Execute(a,op,b);
            //此处需要将v转换为字符型并且入站 
            Push(&OVS,v);
            break; 
        }
    }
    v=GetTop(&OVS,&x);
    return(v);
} 

//初始化
void InitStack(SeqStack *S)
{
    /*构造一个空栈S*/
    S->top=-1; 
} 
//进栈
int Push(SeqStack *S,StackElementType x)
{
    if(S->top==Stack_Size-1)
     return(FALSE);
    S->top++;
    S->elem[S->top]=x;
    return(TRUE);
} 
//出栈
int Pop(SeqStack *S,StackElementType *x)
{
    if(S->top==-1)
     return(FALSE);
    *x=S->elem[S->top];
    S->top--;
    return(TRUE);
} 
//读栈顶
int GetTop(SeqStack *S,StackElementType *x)
{
    if(S->top==-1)
     return(FALSE);
    else
    {
        *x=S->elem[S->top];
        return(TRUE);
    }
} 


//比较优先级，返回'>','<','=' 
StackElementType Compare(StackElementType ch1,StackElementType ch2)
//ch1为还未进栈的运算符，ch2为当前运算符栈顶元素 
{
    //'('未入栈时，优先级最高，入栈后，优先级最低 
    switch(ch1)
    {
        case '(':ch1=6;break;
        case '*':
        case '/':ch1=5;break;
        case '+':
        case '-':ch1=4;break;
        case ')':ch1=3;break;
    }
    switch(ch2)
    {
        case '*':
        case '/':ch2=5;break;
        case '+':
        case '-':ch2=4;break;
        case ')':ch2=3;break;
        case '(':ch2=2;break;
    }
    if(ch1>ch2)
     return('>');
     else if(ch1=ch2)
      return('=');
      else
       return('<');
}
StackElementType Execute(StackElementType a,StackElementType op,StackElementType b)
{
    double v;
    switch(op)
    {
        case '+':v=(double)a+(double)b;break;
        case '-':v=(double)a-(double)b;break;
        case '*':v=(double)a*(double)b;break;
        case '/':v=(double)a/(double)b;break;
    }
    return((StackElementType)v);
}