| 网站首页 | 业界新闻 | 小组 | 威客 | 人才 | 下载频道 | 博客 | 代码贴 | 在线编程 | 编程论坛
欢迎加入我们,一同切磋技术
用户名:   
 
密 码:  
共有 543 人关注过本帖
标题:算术表达式的设计与实现问题!!!!
只看楼主 加入收藏
cl875821804
Rank: 2
等 级:论坛游民
帖 子:25
专家分:10
注 册:2012-11-24
结帖率:75%
收藏
已结贴  问题点数:20 回复次数:6 
算术表达式的设计与实现问题!!!!
程序代码:
#include   <stdio.h>
#include   <string.h>
#include   <stdlib.h>

#define       STACK_INITSIZE 100        //存储空间初始分配量
#define       STACKINCREMENT 10        //存储空间分配量
#define       OPSETSIZE 7                //算符的长度

typedef struct node
{  
  char ch;  
  node *next; 
}Linkstack; 
Linkstack *Setstack()
{                          //创建空链栈  
  Linkstack *S;  
  S=(Linkstack *)malloc(sizeof(Linkstack));  
  S->next=NULL;  
  return S; 
} 
Linkstack *Pushstack(Linkstack *S,char c)
{                                          //入栈  
  Linkstack *p;  
  p=(Linkstack *)malloc(sizeof(Linkstack));  
  p->ch=c;  
  p->next=S->next;  
  S->next=p;  
  return S; 
} 
Linkstack *Popstack(Linkstack *S)
{                          //出栈  
  Linkstack *p;  
  p=S->next;  
  S->next=p->next;  
  free(p);  
  return S; 
} 

char Gettop(Linkstack *S)
{                               //取栈顶数据  
  if(S->next!=NULL)   
  return S->next->ch;  
  else   
  return '  '; 
} 
int Judgepair( )
{                               //判断圆括号是否正确配对  
  Linkstack *p;  
  char c;  
  int sign=1;  
  p=Setstack();  
  printf("请输入算术表达式?并以'#'结束!\n");  
  c=MyExpression;  
  while(c!='#')
  {    
  switch(c){   
  case'(':     //扫描到'('入栈    
  p=Pushstack(p,c); 
  break;   
  case')':     //扫描到')'?判断栈顶是否是'('    
  if(Gettop(p)=='(')     //若栈顶是'(',则出栈     
  p=Popstack(p);    
  else   //若栈顶不是'(',则配对错误     
  sign=0;    
  break;   
       }   
  if(sign==0)    
  break;   
  else    
  c=MyExpression;  
}  
if(p->next!=NULL)  //最后查看栈中是否为空   
sign=0;  
return sign; 
} 

void Judgeout(int a)
{   //判断结果输出  
  if(a==1)   
  printf("算术表达式圆括号配对正确!\n");  
  if(a==0)   
  printf("算术表达式圆括号配对错误!\n"); 
}


/*----------算符栈的结构体--------------*/
typedef       struct
{
    char          * base;            //算符栈的栈底
    char          * top;            //算符栈的栈顶
    int           stacksize;        //算符栈的最大长度
}OPTR_STACK;

/*----------操作数栈的结构体------------*/
typedef struct
{
    double         * base;            //操作数栈的栈底
    double         * top;            //操作数栈的栈顶
    int           stacksize;        //操作数栈的最大长度
}OPND_STACK;


/*-----------*/
int OPTR_InitStack(OPTR_STACK &s)                             // 算符栈的初始化函数
{            
    s.base=(char *)malloc(STACK_INITSIZE*sizeof(char));              // 算符栈分配初始的存储空间
        if(!s.base) return 0;                                          // 若申请存储空间失败,返回0
    s.top=s.base;                                              // 栈顶等于栈底,为空栈
    s.stacksize=STACK_INITSIZE;                                      // 算符栈的最大长度为100
        return  1;
}


char OPTR_GetTop(OPTR_STACK &s)
{                                                // 取算符栈顶元素函数
char e;
if(s.top==s.base)  return 0;                    // 算符栈为空,返回0
      e=*(s.top-1);
      return e;                                    // 返回算符栈顶元素 *(s.top-1)
}


int OPTR_Push(OPTR_STACK &s,char e)             // 算符栈插入元素函数
{            
    if(s.top-s.base>=s.stacksize)               // 当栈的长度超过规定的最大长度s.stacksize时,需要申请额外的存储空间
    {
        s.base=(char *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(char));
        if(!s.base)  return  0;                        // 若申请空间失败,则返回0
        s.top=s.base+s.stacksize;                    // 申请额外空间之前的栈顶位置s.top为s.base+s.stacksize        
        s.stacksize+=STACKINCREMENT;                // 申请额外空间之后的栈的长度增加了STACKINCREMENT
    }
      *s.top++=e;                                    // 若栈的长度未超过规定的最大长度s.stacksize,将元素e入栈顶
      return  1;
}


int OPTR_Pop(OPTR_STACK &s,char &e){                // 算符栈顶元素出栈函数
      if(s.top==s.base) return 0;                    // 若为空栈,返回0
      e=*--s.top;                                    // 不为空栈,将栈顶元素出栈
      return  1;
}


int  OPND_InitStack(OPND_STACK &s)                // 操作数栈的初始化函数
{          
    s.base=(double *)malloc(STACK_INITSIZE*sizeof(double));        // 操作数栈分配初始的存储空间       
        if(!s.base)  return  0;                        // 若申请存储空间失败,返回0
    s.top=s.base;                                    // 栈顶等于栈底,为空栈
    s.stacksize=STACK_INITSIZE;                        // 操作数栈的最大长度为100
        return  1;
}


double OPND_GetTop(OPND_STACK &s)        // 取操作数栈顶元素函数
{      
      double e;
      if(s.top==s.base)  return 0;                // 操作数栈为空,返回0
      e=*(s.top-1);                                // 返回操作数栈顶元素 *(s.top-1)
      return e;
}


int OPND_Push(OPND_STACK &s,double e)            // 操作数栈插入元素函数
{      
      if(s.top-s.base>=s.stacksize)             // 当栈的长度超过规定的最大长度s.stacksize时,需要申请额外的存储空间
        {
            s.base=(double *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(double));
            if(!s.base) return  0;                            // 若申请空间失败,则返回0
            s.top=s.base+s.stacksize;                       // 申请额外空间之前的栈顶位置s.top为s.base+s.stacksize
            s.stacksize+=STACKINCREMENT;                    // 申请额外空间之后的栈的长度增加了STACKINCREMENT
        }
     *s.top++=e;                                            // 若栈的长度未超过规定的最大长度s.stacksize,将元素e入栈顶
  
     return  1;
}


int OPND_Pop(OPND_STACK &s,double &e)                // 操作数栈顶元素出栈函数
{      
      if(s.top==s.base) return  0;                    // 操作数栈为空,返回0
      e=*--s.top;                                    // 不为空栈,将栈顶元素出栈
       return  1;
}

char OPSET[OPSETSIZE]={'+' , '-' , '*' , '/' ,'(' , ')' , '#'};   //7种算符:'+' (加),'-' (减),'*' (乘),'/' (除),'(' (左括号),')' (右括号),'#' (结束符)

char Prior[7][7] = {                                              //7种算符的算符优先级如下
      '>'  ,  '>'  ,  '<'  ,  '<'  ,  '<'  ,  '>'  ,  '>',
      '>'  ,  '>'  ,  '<'  ,  '<'  ,  '<'  ,  '>'  ,  '>',
      '>'  ,  '>'  ,  '>'  ,  '>'  ,  '<'  ,  '>'  ,  '>',
      '>'  ,  '>'  ,  '>'  ,  '>'  ,  '<'  ,  '>'  ,  '>',    
      '<'  ,  '<'  ,  '<'  ,  '<'  ,  '<'  ,  '='  ,  ' ',
      '>'  ,  '>'  ,  '>'  ,  '>'  ,  ' '  ,  '>'  ,  '>',
      '<'  ,  '<'  ,  '<'  ,  '<'  ,  '<'  ,  ' '  ,  '='
};

    
double Operate( double a,  char theta,  double b)                  // 两个数之间的四则运算函数
{    
    switch(theta)                                                  // theta为运算符
        {        
            case '+': return a+b;
            case '-': return a-b;
            case '*': return a*b;
            case '/': return a/b;
            default : return 0;
        } 
}

    
int In(char Test, char * TestOp)                // 算符的判断函数
{   
   int m=0;
   for (int i=0; i< OPSETSIZE; i++)            // 将输入的字符与已知规定的算符比较
         if (Test == TestOp[i])     m=1;
   return m;
}


int ReturnOpOrd(char op, char* TestOp)        //返回该算符在算符数组中的位置的函数
{
    int i;
    for(i=0; i< OPSETSIZE; i++)
        if(op == TestOp[i])     return i;
    return 0;
}


char Precede(char Aop, char Bop)               // 两个算符的优先级的判断函数
{   
    return Prior[ReturnOpOrd(Aop,OPSET)][ReturnOpOrd(Bop,OPSET)];
}


double EvaluateExpression(char  * MyExpression)
{

 /* 表达式的正确性判断函数,同时计算表达式 */
      OPTR_STACK  OPTR;                // OPTR为算符栈
      OPND_STACK  OPND;             // OPND为操作数栈
      char   TempData[40];               // TempData[40]为辅助字符数组
      double  Data,a,b;                   // a和b为进行运算的两个操作数
      char   theta,*c,x,Dr[2];           // theta是算符,*c和x均为字符串的当前字符,Dr[2]保存当前字符和结束符
      OPTR_InitStack (OPTR);                // 初始化算符栈
      OPTR_Push (OPTR, '#');                // '#'入算符栈,作为表达式的第一个字符
      printf("                 #入栈                  \n");
      OPND_InitStack (OPND);                // 初始化操作数栈
      c = MyExpression;                   // 当前c保存字符串MyExpression的首地址
      strcpy(TempData,"\0");
        while (*c!= '#' || OPTR_GetTop(OPTR)!= '#')      // 当字符串的首字符和尾字符同时为#时,运算结束
            {
                if(In(*c, OPSET)==0){              // 若当前字符是操作数
                Dr[0]=*c;                     // Dr[0]保存当前字符
                Dr[1]='\0';                     // Dr[1]保存字符串的结束符'\0'
                strcat(TempData,Dr);            // 将当前字符*c和结束符'\0'连接到字符串TempData中
                c++;
                if(In(*c,OPSET)==1){           // 考虑到操作数有可能不止一位数
                Data=(double)atof(TempData);     // atof函数是将当前字符串转换成浮点型数据
                OPND_Push(OPND, Data);
                strcpy(TempData,"\0");
                printf("                 %.3f入栈                \n",Data);
            }
        } 
        else{    // 若当前字符是算符
            switch (Precede(OPTR_GetTop(OPTR), *c))
            {                                 // 获取当前算符栈的栈顶字符,与*c比较优先级,进行运算

            case '<': 
// 若当前栈顶算符优先级小于*c,则*c入算符栈
                 OPTR_Push(OPTR, *c);
                     printf("                      %c入栈               \n",*c);
                 c++;
                 break;
            case '=':   
// 若当前栈顶算符优先级等于*c,则当前栈顶字符出栈
                 OPTR_Pop(OPTR, x);
                     printf("                  %c出栈                 \n",x);
                 c++;
                 break;
            case '>':  
// 若当前栈顶算符优先级大于*c,则进行运算
                 OPTR_Pop(OPTR, theta);                 // 将栈顶算符出栈
                 printf("            %c  出栈         \n",theta);
                 OPND_Pop(OPND, b);                 // 将栈顶操作数出栈  
                   printf("          %.3f出栈        \n",b);
                 OPND_Pop(OPND, a);                 // 将次栈顶操作数出栈
                   printf("         %.3f出栈        \n",a);
                 OPND_Push(OPND, Operate(a, theta, b));  // 将运算结果入操作数栈
                   printf("         %.3f入栈        \n",Operate(a, theta, b));
                 break;
         } 
      }
}
      return OPND_GetTop(OPND);                          // 返回表达式的运算结果
}
void main()
{
    int x,t=0;
    double   RESULT;
    char    * MyExpression,str[40];
      
      printf("           《 算术表达式的四则运算 》            \n");
      printf("^^本课程设计完成简单的加、减、乘、除四则运算的功能^^\n\n");
      printf("        case 1:  输入表达式           \n");
      printf("        case 2:  输出表达式           \n");
      printf("        case 3:  检验表达式           \n");
      printf("        case 4:  计算表达式           \n");
      printf("        case 0:   退出程序          \n\n");
      for(;;){
            printf(" 请输入您要进行的操作的序号:");
            scanf("%d",&x);
            switch(x){
            case 1:
                t++;    getchar();
                printf("     请输入一个正确的表达式       \n\t\t\t\t");
                gets(str);
                MyExpression=str;
                break;
            case 2:        
                if(t==0)
                printf("您尚未输入表达式,请先进行1操作,然后再进行此操作! \n");
                else{
                    printf("      您输入的表达式为\n\t       ");
                    puts(MyExpression);
                }
                break;
      case3:
  if(t==0)
  printf("您尚未输入表达式,请先进行1操作,然后再进行此操作! \n");
  else
  Judgeout(Judgepair());
  break;
            case 4:
                if(t==0)
            printf("您尚未输入表达式,请先进行1操作,然后再进行此操作!       \n");
                else
                {
                    RESULT=EvaluateExpression(MyExpression);
                    printf("  算术表达式的结果:%.3f   \n",RESULT);
                }
                break;    
            case 0:
                printf("      欢迎使用,BYE BYE ^^__^^      \n");
                exit(0);
            default:
                printf("      操作序号错误,请重新输入    !\n");
                break;
            }
        }
}

在case3,检验表达式处错误,请各位大神指教指教!!!!
搜索更多相关主题的帖子: 表达式 设计 
2013-05-08 22:19
小小玉
Rank: 3Rank: 3
等 级:论坛游侠
帖 子:47
专家分:156
注 册:2013-4-13
收藏
得分:7 
你自己就是大神。
2013-05-08 22:21
wkz2012
Rank: 4
等 级:业余侠客
帖 子:123
专家分:253
注 册:2012-12-13
收藏
得分:7 
太长了,不想看了

我了个去的编程!
2013-05-08 23:19
迪达拉
Rank: 9Rank: 9Rank: 9
等 级:蜘蛛侠
威 望:3
帖 子:479
专家分:1070
注 册:2013-4-3
收藏
得分:7 
手机   看的不准  case 3;

我认识一个人,因为撒了一泡尿,被关了五百年
2013-05-08 23:38
迪达拉
Rank: 9Rank: 9Rank: 9
等 级:蜘蛛侠
威 望:3
帖 子:479
专家分:1070
注 册:2013-4-3
收藏
得分:0 
空格

我认识一个人,因为撒了一泡尿,被关了五百年
2013-05-08 23:38
cl875821804
Rank: 2
等 级:论坛游民
帖 子:25
专家分:10
注 册:2012-11-24
收藏
得分:0 
那个是个小错误,主要是类型不符合,想问问怎么修改

just do it
2013-05-09 00:37
cl875821804
Rank: 2
等 级:论坛游民
帖 子:25
专家分:10
注 册:2012-11-24
收藏
得分:0 
重新调试了下,在函数int Judgeout()中的c=MyExpression这条语句有问题,我给注释了,谁知道 的给改下

程序代码:
#include   <stdio.h>
#include   <string.h>
#include   <stdlib.h>

#define       STACK_INITSIZE 100        //存储空间初始分配量
#define       STACKINCREMENT 10        //存储空间分配量
#define       OPSETSIZE 7                //算符的长度

typedef struct node
{  
    char ch;
    struct node *next;
}Linkstack; 
Linkstack *Setstack()
{                          //创建空链栈  
    Linkstack *S;
    S=(Linkstack *)malloc(sizeof(Linkstack));
    S->ch=NULL;
    return S;
} 
Linkstack *Pushstack(Linkstack *S,char c)
{                                          //入栈  
    Linkstack *p;
    p=(Linkstack *)malloc(sizeof(Linkstack));
    p->ch=c;
    p->next=S->next;
    S->next=p;
        return S;
} 
Linkstack *Popstack(Linkstack *S)
{                          //出栈  
    Linkstack *p;
    p=S->next;
    S->next=p->next;
    free(p);
    return S;
} 

char Gettop(Linkstack *S)
{                               //取栈顶数据  
    if(S->next!=NULL)
        return S->next->ch;
    else
        return ' ';
} 
int Judgepair( )
{                               //判断圆括号是否正确配对  
    Linkstack *p;
    char c;
    int sign=1;
    p=Setstack();
    //c=MyExpression;
    while(c!='#')
    {
        switch(c){
            case'(':
                p=Pushstack(p,c);
            break;
            case')':
                if(Gettop(p)=='(')
                    p=Popstack(p);
                else
                    sign=0;
            break;
        }
        if(sign==0)
            break;
        //else
            //c=MyExpression;
    }
    if(p->next!=NULL)
        sign=0;
    return sign;
}

void Judgeout(int a)
{
    if(a==1)
        printf("算数表达式圆括号配对正确!\n");
    if(a==0)
        printf("算数表达式圆括号配对错误!\n");
}

/*----------算符栈的结构体--------------*/
typedef       struct
{
    char          * base;            //算符栈的栈底
    char          * top;            //算符栈的栈顶
    int           stacksize;        //算符栈的最大长度
}OPTR_STACK;

/*----------操作数栈的结构体------------*/
typedef struct
{
    double         * base;            //操作数栈的栈底
    double         * top;            //操作数栈的栈顶
    int           stacksize;        //操作数栈的最大长度
}OPND_STACK;


/*-----------*/
int OPTR_InitStack(OPTR_STACK &s)                             // 算符栈的初始化函数
{            
    s.base=(char *)malloc(STACK_INITSIZE*sizeof(char));              // 算符栈分配初始的存储空间
        if(!s.base) return 0;                                          // 若申请存储空间失败,返回0
    s.top=s.base;                                              // 栈顶等于栈底,为空栈
    s.stacksize=STACK_INITSIZE;                                      // 算符栈的最大长度为100
        return  1;
}


char OPTR_GetTop(OPTR_STACK &s)
{                                                // 取算符栈顶元素函数
char e;
if(s.top==s.base)  return 0;                    // 算符栈为空,返回0
      e=*(s.top-1);
      return e;                                    // 返回算符栈顶元素 *(s.top-1)
}


int OPTR_Push(OPTR_STACK &s,char e)             // 算符栈插入元素函数
{            
    if(s.top-s.base>=s.stacksize)               // 当栈的长度超过规定的最大长度s.stacksize时,需要申请额外的存储空间
    {
        s.base=(char *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(char));
        if(!s.base)  return  0;                        // 若申请空间失败,则返回0
        s.top=s.base+s.stacksize;                    // 申请额外空间之前的栈顶位置s.top为s.base+s.stacksize        
        s.stacksize+=STACKINCREMENT;                // 申请额外空间之后的栈的长度增加了STACKINCREMENT
    }
      *s.top++=e;                                    // 若栈的长度未超过规定的最大长度s.stacksize,将元素e入栈顶
      return  1;
}


int OPTR_Pop(OPTR_STACK &s,char &e){                // 算符栈顶元素出栈函数
      if(s.top==s.base) return 0;                    // 若为空栈,返回0
      e=*--s.top;                                    // 不为空栈,将栈顶元素出栈
      return  1;
}


int  OPND_InitStack(OPND_STACK &s)                // 操作数栈的初始化函数
{          
    s.base=(double *)malloc(STACK_INITSIZE*sizeof(double));        // 操作数栈分配初始的存储空间       
        if(!s.base)  return  0;                        // 若申请存储空间失败,返回0
    s.top=s.base;                                    // 栈顶等于栈底,为空栈
    s.stacksize=STACK_INITSIZE;                        // 操作数栈的最大长度为100
        return  1;
}


double OPND_GetTop(OPND_STACK &s)        // 取操作数栈顶元素函数
{      
      double e;
      if(s.top==s.base)  return 0;                // 操作数栈为空,返回0
      e=*(s.top-1);                                // 返回操作数栈顶元素 *(s.top-1)
      return e;
}


int OPND_Push(OPND_STACK &s,double e)            // 操作数栈插入元素函数
{      
      if(s.top-s.base>=s.stacksize)             // 当栈的长度超过规定的最大长度s.stacksize时,需要申请额外的存储空间
        {
            s.base=(double *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(double));
            if(!s.base) return  0;                            // 若申请空间失败,则返回0
            s.top=s.base+s.stacksize;                       // 申请额外空间之前的栈顶位置s.top为s.base+s.stacksize
            s.stacksize+=STACKINCREMENT;                    // 申请额外空间之后的栈的长度增加了STACKINCREMENT
        }
     *s.top++=e;                                            // 若栈的长度未超过规定的最大长度s.stacksize,将元素e入栈顶
  
     return  1;
}


int OPND_Pop(OPND_STACK &s,double &e)                // 操作数栈顶元素出栈函数
{      
      if(s.top==s.base) return  0;                    // 操作数栈为空,返回0
      e=*--s.top;                                    // 不为空栈,将栈顶元素出栈
       return  1;
}

char OPSET[OPSETSIZE]={'+' , '-' , '*' , '/' ,'(' , ')' , '#'};   //7种算符:'+' (加),'-' (减),'*' (乘),'/' (除),'(' (左括号),')' (右括号),'#' (结束符)

char Prior[7][7] = {                                              //7种算符的算符优先级如下
      '>'  ,  '>'  ,  '<'  ,  '<'  ,  '<'  ,  '>'  ,  '>',
      '>'  ,  '>'  ,  '<'  ,  '<'  ,  '<'  ,  '>'  ,  '>',
      '>'  ,  '>'  ,  '>'  ,  '>'  ,  '<'  ,  '>'  ,  '>',
      '>'  ,  '>'  ,  '>'  ,  '>'  ,  '<'  ,  '>'  ,  '>',    
      '<'  ,  '<'  ,  '<'  ,  '<'  ,  '<'  ,  '='  ,  ' ',
      '>'  ,  '>'  ,  '>'  ,  '>'  ,  ' '  ,  '>'  ,  '>',
      '<'  ,  '<'  ,  '<'  ,  '<'  ,  '<'  ,  ' '  ,  '='
};

    
double Operate( double a,  char theta,  double b)                  // 两个数之间的四则运算函数
{    
    switch(theta)                                                  // theta为运算符
        {        
            case '+': return a+b;
            case '-': return a-b;
            case '*': return a*b;
            case '/': return a/b;
            default : return 0;
        } 
}

    
int In(char Test, char * TestOp)                // 算符的判断函数
{   
   int m=0;
   for (int i=0; i< OPSETSIZE; i++)            // 将输入的字符与已知规定的算符比较
         if (Test == TestOp[i])     m=1;
   return m;
}


int ReturnOpOrd(char op, char* TestOp)        //返回该算符在算符数组中的位置的函数
{
    int i;
    for(i=0; i< OPSETSIZE; i++)
        if(op == TestOp[i])     return i;
    return 0;
}


char Precede(char Aop, char Bop)               // 两个算符的优先级的判断函数
{   
    return Prior[ReturnOpOrd(Aop,OPSET)][ReturnOpOrd(Bop,OPSET)];
}


double EvaluateExpression(char  * MyExpression)
{
/* 表达式的正确性判断函数,同时计算表达式 */
      OPTR_STACK  OPTR;                // OPTR为算符栈
      OPND_STACK  OPND;             // OPND为操作数栈
      char   TempData[40];               // TempData[40]为辅助字符数组
      double  Data,a,b;                   // a和b为进行运算的两个操作数
      char   theta,*c,x,Dr[2];           // theta是算符,*c和x均为字符串的当前字符,Dr[2]保存当前字符和结束符
      OPTR_InitStack (OPTR);                // 初始化算符栈
      OPTR_Push (OPTR, '#');                // '#'入算符栈,作为表达式的第一个字符
      printf("                 #入栈                  \n");
      OPND_InitStack (OPND);                // 初始化操作数栈
      c = MyExpression;                   // 当前c保存字符串MyExpression的首地址
      strcpy(TempData,"\0");
        while (*c!= '#' || OPTR_GetTop(OPTR)!= '#')      // 当字符串的首字符和尾字符同时为#时,运算结束
            {
                if(In(*c, OPSET)==0){              // 若当前字符是操作数
                Dr[0]=*c;                     // Dr[0]保存当前字符
                Dr[1]='\0';                     // Dr[1]保存字符串的结束符'\0'
                strcat(TempData,Dr);            // 将当前字符*c和结束符'\0'连接到字符串TempData中
                c++;
                if(In(*c,OPSET)==1){           // 考虑到操作数有可能不止一位数
                Data=(double)atof(TempData);     // atof函数是将当前字符串转换成浮点型数据
                OPND_Push(OPND, Data);
                strcpy(TempData,"\0");
                printf("                 %.3f入栈                \n",Data);
            }
        } 
        else{    // 若当前字符是算符
            switch (Precede(OPTR_GetTop(OPTR), *c))
            {                                 // 获取当前算符栈的栈顶字符,与*c比较优先级,进行运算

            case '<': 
// 若当前栈顶算符优先级小于*c,则*c入算符栈
                 OPTR_Push(OPTR, *c);
                     printf("                      %c入栈               \n",*c);
                 c++;
                 break;
            case '=':   
// 若当前栈顶算符优先级等于*c,则当前栈顶字符出栈
                 OPTR_Pop(OPTR, x);
                     printf("                  %c出栈                 \n",x);
                 c++;
                 break;
            case '>':  
// 若当前栈顶算符优先级大于*c,则进行运算
                 OPTR_Pop(OPTR, theta);                 // 将栈顶算符出栈
                 printf("            %c  出栈         \n",theta);
                 OPND_Pop(OPND, b);                 // 将栈顶操作数出栈  
                   printf("          %.3f出栈        \n",b);
                 OPND_Pop(OPND, a);                 // 将次栈顶操作数出栈
                   printf("         %.3f出栈        \n",a);
                 OPND_Push(OPND, Operate(a, theta, b));  // 将运算结果入操作数栈
                   printf("         %.3f入栈        \n",Operate(a, theta, b));
                 break;
         } 
      }
}
      return OPND_GetTop(OPND);                          // 返回表达式的运算结果
}
void main()
{
    int x,t=0;
    double   RESULT;
    char    * MyExpression,str[40];
      
      printf("           《 算术表达式的四则运算 》            \n");
      printf("^^本课程设计完成简单的加、减、乘、除四则运算的功能^^\n\n");
      printf("        case 1:  输入表达式           \n");
      printf("        case 2:  输出表达式           \n");
      printf("        case 3:  检验表达式           \n");
      printf("        case 4:  计算表达式           \n");
      printf("        case 0:   退出程序          \n\n");
      for(;;){
            printf(" 请输入您要进行的操作的序号:");
            scanf("%d",&x);
            switch(x){
            case 1:
                t++;
                getchar();
                printf("     请输入一个正确的表达式       \n\t\t\t\t");
                gets(str);
                MyExpression=str;
                break;
            case 2:        
                if(t==0)
                printf("您尚未输入表达式,请先进行1操作,然后再进行此操作! \n");
                else{
                    printf("      您输入的表达式为\n\t       ");
                    puts(MyExpression);
                }
                break;
            case 3:
                if(t==0)
                printf("您尚未输入表达式,请先进行1操作,然后再进行此操作! \n");
                else
                    Judgeout(Judgepair());
            case 4:
                if(t==0)
            printf("您尚未输入表达式,请先进行1操作,然后再进行此操作!       \n");
                else
                {
                    RESULT=EvaluateExpression(MyExpression);
                    printf("  算术表达式的结果:%.3f   \n",RESULT);
                }
                break;    
            case 0:
                printf("      欢迎使用,BYE BYE ^^__^^      \n");
                exit(0);
            default:
                printf("      操作序号错误,请重新输入    !\n");
                break;
            }
        }
}

just do it
2013-05-09 10:58
快速回复:算术表达式的设计与实现问题!!!!
数据加载中...
 
   



关于我们 | 广告合作 | 编程中国 | 清除Cookies | TOP | 手机版

编程中国 版权所有,并保留所有权利。
Powered by Discuz, Processed in 0.042861 second(s), 7 queries.
Copyright©2004-2024, BCCN.NET, All Rights Reserved