精华内容
下载资源
问答
  • 用两种方式实现表达式自动计算 - PAGE 2 - 设计思想 计算算术表达式可以用两种方法实现 1.中缀转后缀算法 此算法分两步实现先将算术表达式转换为后缀表达式然后对后缀表达式进行计算具体实现方法如下 中缀转后缀 ...
  • 声明:这个程序可以计算+,-,*,/,负数,小数 负数用括号括起来例如(-1) 负数的计算过程:(-1) 转变为 (0-1) 哈哈~   分成六个点: 1.我的文件结构 2.顺序堆栈的头文件 3.头文件引入与自定义的常量...

    声明:这个程序可以计算+,-,*,/,负数,小数

    负数用括号括起来例如(-1)

    负数的计算过程:(-1)  转变为 (0-1)  哈哈~

     

    分成六个点:

    1.我的文件结构

    2.顺序堆栈的头文件

    3.头文件引入与自定义的常量和类型

    4.主处理函数

    5.测试的主函数

    6.测试结果

     

    1.我的文件结构

    有两个文件        1.expCop.c     里面的内容是:头文件与自定义的常量和类型、主处理函数、测试的主函数

                              2.SqeStack.h  里面的内容是:栈的定义与处理函数

    2.顺序堆栈的头文件

    typedef struct{
        DataType stack[MaxStackSize];
        int top;
    }SeqStack;
    
    
    //栈初始化
    void StackInitiate(SeqStack *S){
        S->top = 0;
    }
    //判断栈是否为空
    int StackNotEmpty(SeqStack S){
        if(S.top==0){
            return 0;
        }
        return 1;
    }
    //入栈
    int StackPush(SeqStack *S,DataType x){
        if(S->top>=MaxStackSize){
            printf("堆栈已满无法插入!\n");
            return 0;
        }else{
            S->stack[S->top]=x;
            S->top++;
            return 1;
        }
    }
    //出栈
    int StackPop(SeqStack *S,DataType *d){
        if(S->top<=0){
            printf("StackPop堆栈为空!\n");
            return 0;
        }else{
            S->top--;
            *d = S->stack[S->top];
            return 1;
        }
    }
    //获取栈顶数据元素
    int StackTop(SeqStack S,DataType *d){
        if(S.top<=0){
            printf("StackTop堆栈为空!\n");
            return 0;
        }else{
            *d = S.stack[S.top-1];
            return 1;
        }
    }
    
    
    

     3.头文件引入与自定义的常量和类型

    typedef char DataType;//定义栈的数据存数的类型
    #define MaxStackSize 100//定义栈的大小
    #include <stdio.h>//这个不用多说
    #include <string.h>//字符串处理(自带)
    #include <math.h>//用来处理小数,用到了pow(自带)
    #include "SeqStack.h"//这是顺序堆栈的头文件(需要自己建立)

    4.主处理函数

    double expressionComputation(char *exp){
        SeqStack myStack;//对操作符进行中缀到后缀
        StackInitiate(&myStack);
        double num[100];//保存操作数 注:在弹出操作符的以后要立刻取出num最后面两个数字进行运算后存回num中
        int numSize = 0;
        int i,j;
        int spot = 0;
        char c;
        for(i=0;i<strlen(exp);i++){
            if((exp[i]=='0'||exp[i]=='1'||exp[i]=='2'||exp[i]=='3'||exp[i]=='4'||exp[i]=='5'||exp[i]=='6'||exp[i]=='7'||exp[i]=='8'||exp[i]=='9')&&spot==0){
                j=i+1;
                while(exp[j]=='0'||exp[j]=='1'||exp[j]=='2'||exp[j]=='3'||exp[j]=='4'||exp[j]=='5'||exp[j]=='6'||exp[j]=='7'||exp[j]=='8'||exp[j]=='9'){
                    j++;
                }
                num[numSize] = num[numSize] + (exp[i]-'0') * pow(10,j-i-1);
                if(j-i-1==0&&exp[j]!='.'){
                    numSize++;
                }
                continue;
            }
            if(exp[i]=='.'||spot==1){
                spot=1;
                if(exp[i]=='.'){
                    j=0;
                    continue;
                }else{
                    j--;
                }
                num[numSize] = num[numSize] + (exp[i]-'0') * pow(10,j);
                if(exp[i+1]!='0'&&exp[i+1]!='1'&&exp[i+1]!='2'&&exp[i+1]!='3'&&exp[i+1]!='4'&&exp[i+1]!='5'&&exp[i+1]!='6'&&exp[i+1]!='7'&&exp[i+1]!='8'&&exp[i+1]!='9'){
                    numSize++;
                    spot=0;
                }
            }
            if(exp[i]=='+'){
                if(!StackNotEmpty(myStack)){
                    StackPush(&myStack,exp[i]);
                }else if(StackTop(myStack,&c)&&(c=='*'||c=='/'||c=='-'||c=='+')){
                    while(StackTop(myStack,&c)&&(c=='*'||c=='/'||c=='-'||c=='+')){
                        StackPop(&myStack,&c);
                        switch(c){
                            case '*':num[numSize-2] = num[numSize-2]*num[numSize-1];
                                     numSize--;
                                     num[numSize]=0;
                                     break;
                            case '/':num[numSize-2] = num[numSize-2]/num[numSize-1];
                                     numSize--;
                                     num[numSize]=0;
                                     break;
                            case '-':num[numSize-2] = num[numSize-2]-num[numSize-1];
                                     numSize--;
                                     num[numSize]=0;
                                     break;
                            case '+':num[numSize-2] = num[numSize-2]+num[numSize-1];
                                     numSize--;
                                     num[numSize]=0;
                                     break;
                        }
                        if(!StackNotEmpty(myStack)){
                            break;
                        }
                    }
                    StackPush(&myStack,exp[i]);
                }else if(StackTop(myStack,&c)&&c=='('){
                    StackPush(&myStack,exp[i]);
                }
            }
            if(exp[i]=='-'){
                if(exp[i-1]!='0'&&exp[i-1]!='1'&&exp[i-1]!='2'&&exp[i-1]!='3'&&exp[i-1]!='4'&&exp[i-1]!='5'&&exp[i-1]!='6'&&exp[i-1]!='7'&&exp[i-1]!='8'&&exp[i-1]!='9'&&exp[i-1]!='('&&exp[i-1]!=')'){
                    printf("输入格式错误!Tip:负数请加括号如(-1)\n");
                    break;
                }
                if(!StackNotEmpty(myStack)){
                    StackPush(&myStack,exp[i]);
                }else if(StackTop(myStack,&c)&&(c=='*'||c=='/'||c=='+'||c=='-')){
                    while(StackTop(myStack,&c)&&(c=='*'||c=='/'||c=='+'||c=='-')){
                        StackPop(&myStack,&c);
                        switch(c){
                            case '*':num[numSize-2] = num[numSize-2]*num[numSize-1];
                                     numSize--;
                                     num[numSize]=0;
                                     break;
                            case '/':num[numSize-2] = num[numSize-2]/num[numSize-1];
                                     numSize--;
                                     num[numSize]=0;
                                     break;
                            case '+':num[numSize-2] = num[numSize-2]+num[numSize-1];
                                     numSize--;
                                     num[numSize]=0;
                                     break;
                            case '-':num[numSize-2] = num[numSize-2]-num[numSize-1];
                                     numSize--;
                                     num[numSize]=0;
                                     break;
                        }
                        if(!StackNotEmpty(myStack)){
                            break;
                        }
                    }
                    StackPush(&myStack,exp[i]);
                }else if(StackTop(myStack,&c)&&(c=='('||c==')')){
                    StackPush(&myStack,exp[i]);
                }
            }
            if(exp[i]=='*'){
                if(!StackNotEmpty(myStack)||(StackTop(myStack,&c)&&(c=='+'||c=='-'))){
                    StackPush(&myStack,exp[i]);
                }else if(StackTop(myStack,&c)&&(c=='/')){
                    StackPop(&myStack,&c);
                    switch(c){
                        case '/':num[numSize-2] = num[numSize-2]/num[numSize-1];
                                 numSize--;
                                 num[numSize]=0;
                                 break;
                    }
                    StackPush(&myStack,exp[i]);
                }else if(StackTop(myStack,&c)&&(c=='('||c==')')){
                    StackPush(&myStack,exp[i]);
                }
            }
            if(exp[i]=='/'){
                if(!StackNotEmpty(myStack)||(StackTop(myStack,&c)&&(c=='+'||c=='-'))){
                    StackPush(&myStack,exp[i]);
                }else if(StackTop(myStack,&c)&&(c=='*')){
                    StackPop(&myStack,&c);
                    switch(c){
                        case '*':num[numSize-2] = num[numSize-2]*num[numSize-1];
                                 numSize--;
                                 num[numSize]=0;
                                 break;
                    }
                    StackPush(&myStack,exp[i]);
                }else if(StackTop(myStack,&c)&&(c=='('||c==')')){
                    StackPush(&myStack,exp[i]);
                }
            }
            if(exp[i]=='('){
                StackPush(&myStack,exp[i]);
                if(exp[i+1]=='-'){
                    int k=strlen(exp);
                    while(k-1>i){
                        exp[k]=exp[k-1];
                        k--;
                    }
                    exp[i+1]='0';
                }
    
            }
            if(exp[i]==')'){
                while(StackTop(myStack,&c)&&c!='('){
                    StackPop(&myStack,&c);
                    switch(c){
                        case '*':num[numSize-2] = num[numSize-2]*num[numSize-1];
                                 numSize--;
                                 num[numSize]=0;
                                 break;
                        case '/':num[numSize-2] = num[numSize-2]/num[numSize-1];
                                 numSize--;
                                 num[numSize]=0;
                                 break;
                        case '+':num[numSize-2] = num[numSize-2]+num[numSize-1];
                                 numSize--;
                                 num[numSize]=0;
                                 break;
                        case '-':num[numSize-2] = num[numSize-2]-num[numSize-1];
                                 numSize--;
                                 num[numSize]=0;
                                 break;
                    }
                }
                StackPop(&myStack,&c);
            }
        }
        while(StackNotEmpty(myStack)){
            StackPop(&myStack,&c);
            switch(c){
                case '*':num[numSize-2] = num[numSize-2]*num[numSize-1];
                         numSize--;
                         num[numSize]=0;
                         break;
                case '/':num[numSize-2] = num[numSize-2]/num[numSize-1];
                         numSize--;
                         num[numSize]=0;
                         break;
                case '+':num[numSize-2] = num[numSize-2]+num[numSize-1];
                         numSize--;
                         num[numSize]=0;
                         break;
                case '-':num[numSize-2] = num[numSize-2]-num[numSize-1];
                         numSize--;
                         num[numSize]=0;
                         break;
            }
        }
        return num[0];//最后的值
    }

    5.测试的主函数

    void main(void){
        char exp[200]="";
        printf("请输入一个表达式\t形如:2+3+(-5)+1.2\n");
        scanf("%s",exp);
        printf("\n结果为:%lf",expressionComputation(exp));
    }
    

    6.测试结果

     

     

    可能会存在其他意想不到的错误,若测试出现其他错误请指正,我会加以修正。

    展开全文
  • c语言中缀表达式计算

    2015-01-03 18:15:23
    利用c语言写的中缀表达式,主要数据结构是栈。
  • 这是一个C语言系列文章,如果是初学者的话,建议先行阅读之前的文章。笔者也会按照章节顺序发布。在上一篇的示例中其实出现过很多表达式和语句,例如:int a = 1 + 2;其中,1 + 2是一个表达式, a = 1 + 2也是一个...

    这是一个C语言系列文章,如果是初学者的话,建议先行阅读之前的文章。笔者也会按照章节顺序发布。

    ca27e72cad8cfda409b755956775526a.png

    在上一篇的示例中其实出现过很多表达式和语句,例如:

    int a = 1 + 2;

    其中,1 + 2是一个表达式, a = 1 + 2也是一个表达式, 而整个这句则是一个语句。

    表达式

    表达式是一种由运算符和操作数组成的结构。下面我们看一些表达式例子:

    1 + 2 //加号为加法运算符,1和2为加法运算符相关的操作数2 >> 1 //>>为右移运算符,2和1为运算符相关的操作数func(1,2) //这是一个函数调用,初学者可以暂时不考虑什么是函数,我们将在后面介绍//在这个例子中,可以将函数名与()看作运算符,而括号内的数为操作数。//大家可以回看上一篇中运算符表中的括号运算符的使用形式。

    每一个表达式都有一个表达式值

    例如1 + 2,我们都知道等于3,3就是这个加法表达式的值。

    再例如2 >> 1,我们也知道等于1,1就是这个右移表达式的值。

    最后看下func(1,2)这样的表达式,它的值是函数func的返回值,初学者不必纠结于此。

    上一篇我们介绍的运算符中有一个自加和自减的运算符,我们来看下例子:

    int a = 10;//下面这四个表达式的值和变量a的值分别是多少呢++a //a的值11,表达式值11a++ //a的值11,表达式值10--a //a的值9,表达式值9a-- //a的值9,表达式值10

    可以看到,凡是自加/自减运算符在前的,a的值和表达式的值都是经过运算后的值,而运算符在后的,a的值是运算后的值,表达式的值则是运算前的值。

    再来看一个上一篇的例子:

    int a = (1,2,3);

    其实,逗号运算符表达式中每一个被逗号隔开的部分都是一个子表达式,即:

    int a = (1+2, 3+4, 5+6);

    是完全符合语法要求的,而逗号表达式的值是最后一个子表达式的值(逗号运算符结合方向为左到右,所以是最右侧的),即11。

    语句

    语句是C语言中的基本组成元素,一个C语言程序的源码必然是由语句组成的。

    语句的形式有很多种,大致分为:

    1. 表达式语句
    2. 变量定义/声明语句
    3. 函数定义/声明语句
    4. 结构体定义/声明语句
    5. 共同体定义/声明语句
    6. 枚举定义/声明语句
    7. 类型定义/声明语句
    8. 循环控制语句

    初学者对上面未听说过的内容不必纠结,我们后面会逐个专门介绍,这里只是进行一个汇总。

    上面这8类中,除函数和循环控制类语句以外,其余均以分号做结尾的。

    其中声明是告知编译器,这个变量、函数、结构体等在本文件内或者其他文件内有定义。

    下面给出每种语句的一个样例,我们主要看表达式语句、变量相关语句,其余的粗略了解即可。

    • 表达式语句
    a = 1; //a=1是由赋值运算符组成的赋值表达式,在表达式后加一个分号,就变成了赋值语句。a = 1 + 2; //1+2是加法运算符组成的加法表达式,其优先级高于赋值运算符,所以先计算加法//加法表达式的值为3,然后是由等号组成的赋值表达式,表达式的值为3(即等号右侧表达式的值)。//最后,在赋值表达式后增加一个分号,变成一条语句。a = b = 1; //由于赋值表达式也有表达式值,因此可以使用这种写法同时给变量a和变量b赋值,他们的值都是1。
    • 变量定义/声明语句
    int a; //最基本的变量定义语句,并未给a赋初始值。//定义语句包含了变量的类型、变量名和分号。int a = 1;//增加了赋值表达式,给变量定义语句中的变量赋初始值。static int a = 1; //static在此表示静态变量,后面章节我们会介绍到int a; //声明变量a与定义写法一致static int a; //声明本地变量aextern int a; //声明外部变量a
    • 函数定义/声明语句
    int foo (int arg1, char arg2){  //...  return 0;}//定义返回值为整型的函数foo,且函数有两个参数——整型arg1和字符型arg2int foo (int arg1, char arg2);//与定义类似,但是省略{}及其内容,并用分号结尾int foo (int, char); //函数声明可省略参数名static int foo (int, char); //声明本地函数extern int foo (int, char); //声明外部函数
    • 结构体定义/声明语句
    struct person {  char name[256];  int age;};//定义名为person的结构体,其中包含字符型数组name和整型变量agestatic struct person; //声明本地结构体personextern struct person; //声明外部结构体person
    • 共同体定义/声明语句
    union volunteer {  struct person john;  struct person susan;};//定义名为volunteer的共同体,其中包含两个struct person对象john和susan。共同体中只能操作其中一个成员
    • 枚举定义/声明语句
    enum identity; {    teach,    student};//定义名为identity的枚举类型,其中含有teach和student成员。static enum 
    • 类型定义/声明语句
    typedef struct person person_t; //定义类型person_t,其类型等价于结构体struct personstatic person_t; //声明本地类型person_textern person_t; //声明外部类型person_t
    • 循环控制语句
    for (i = 0; i < 10; ++i) {  //...}//for循环语句while (i < 10) {  //...}//while 循环语句do {  //...} while (i < 3);//do-while循环语句switch (c) {  case 'a':    //...    break;  case 'b':    //...    break;  default:    //...    break;}//switch语句if (i < 10) {  //...} else {  //...}//if-else语句

    语句表达式

    关于语句表达式这一特殊结构,感兴趣的读者请参考码哥的另一篇文章,《你应该知道的GNU C语句表达式》。

    忽略本小节内容并不影响后续C语言的学习和使用

    喜欢的读者可以关注码哥,也可以在下方留言评论,如果有不清楚的地方也可以私信码哥,我会第一时间回复。

    感谢阅读!

    展开全文
  • C语言实现表达式计算

    2010-04-21 10:40:30
    本段程序为以课程的作业(数据结构),有两段程序(中缀转后缀计算表达式,直接计算两种),完全用turbo c编写,兼容性良好(不存在turbo c上能运行,在vc上报错的现象)!当时做的时候费了很多脑经,现在分享出来,...
  • 第二步,读出后缀表达式并进行计算;边转换边计算的算法;此算法的基本思路是将中缀表达式按照转换后缀的表达;首先,用一个char数组将中缀表达式读入,对数组;为了方便计算计算 一、设计思想 两种

    一、设计思想;两种算法首先都要建立两个栈,一个是存放操作数的数;中缀转后缀再计算的算法;此算法的基本思路是先将中缀表达式转换成后缀表达式;首先,用一个char数组将中缀表达式读入,对数组;第二步,读出后缀表达式并进行计算;边转换边计算的算法;此算法的基本思路是将中缀表达式按照转换后缀的表达;首先,用一个char数组将中缀表达式读入,对数组;为了方便计算,计算


    一、设计思想

    两种算法首先都要建立两个栈,一个是存放操作数的数栈OdStack,一个是存放运算符的符栈OpStack。数栈采用double型的用来存放浮点数,符栈采用char型的用来存放运算符,由于考虑到运算符有优先级的问题,所以事先做了一个Type用来存储运算符的优先级。栈建立好了之后做栈的相关操作,初始化栈,入栈,出栈,看栈顶。其中入栈要判满,出栈和看栈顶要判空。

    中缀转后缀再计算的算法。

    此算法的基本思路是先将中缀表达式转换成后缀表达式,之后再利用后缀表达式的算法对表达式进行计算。

    首先,用一个char数组将中缀表达式读入,对数组中的每一个元素进行处理,区分哪些是数,哪些是运算符。如果是数元素(或小数点元素),则依次存入用来存储后缀表达式的char数组,直到一个整合数存完之后用空格将其与后面的元素分开。如果是运算符元素,则根据当前运算符的优先级和栈里面的运算符的优先级进行处理。如果栈内元素的优先级小于当前元素的优先级或者栈内为空,则将当前运算符入栈;如果栈内元素的优先级大于等于当前元素的,则依次将出栈元素存入后缀表达式,并用空格将其与后面的元素分开,直到栈内元素的优先级小或者栈内为空。对于左括号来说,无条件进栈,并只在有右括号出现的时候才有可能出栈。对于右括号来说,无条件让栈内元素出栈,直到左括号出栈。依次将每个元素进行处理直到中缀表达式索引完毕。至此,已经实现了将中缀表达式转换成了后缀表达式,在数组的最后加上结束符以便下一步的调用。

    第二步,读出后缀表达式并进行计算。如果索引到空格则将索引标志后推1位。之后要先对char型的数字元素进行整合,从后缀表达式中依次取出数字元素(连同小数点)存入一个新的char型数组,直到一整个数取完后通过atof函数将char型转换成浮点型存入数栈,并将新数组初始化用来存储下一个数。如果是索引到运算符,则在数栈中出栈两个数字与当前运算符进行运算,先出栈的数字放在运算符后面,后出栈的数字放在运算符的前面,将运算以后的结果再次存入数栈。依次进行计算直到后缀表达式索引完毕。此时对栈内剩余元素进行操作。每在符栈出栈一个运算符,就从数栈出栈两个数进行计算,算法同上,将运算以后的结果再次存入数栈。循环操作直到符栈栈空,此时数栈出栈元素即为最后结果。

    边转换边计算的算法。

    此算法的基本思路是将中缀表达式按照转换后缀的表达式的方法逐步进行,边转换边进行计算和存储。

    首先,用一个char数组将中缀表达式读入,对数组中的每一个元素进行处理,区分哪些是数,哪些是运算符。如果是数元素(或小数点元素),则利用如上算法先进行元素整合,并将整合的元素通过atof函数将char型转换成浮点型存入数栈,并将新数组初始化用来存储下一个数。如果是索引到运算符,则要先根据当前运算符的优先级和栈里面的运算符的优先级进行处理。如果栈内元素的优先级小于当前元素的优先级或者栈内为空,则将当前运算符入栈;如果栈内元素的优先级大于等于当前元素的,则依次出栈元素进行计算。每次计算要在数栈出栈两个整合后的数,先出栈的数字放在运算符后面,后出栈的数字放在运算符的前面,将运算以后的结果再次存入数栈。如果遇到左括号则无条件进栈,并只在有右括号出现的时候才有可能出栈。如果遇到右括号,则无条件让栈内元素出栈进行计算,直到左括号出栈为止。如此计算将表达式所有元素全部索引。之后再对栈内剩余元素进行操作。每在符栈出栈一个运算符,就从数栈出栈两个数进行计算,算法同上,将运算以后的结果再次存入数栈。循环操作直到符栈栈空,此时数栈出栈元素即为最后结果。

    为了方便计算,计算过程使用了函数体。主函数只负责输入中缀表达式和输出最后的运

    算结果。同时,建立了优先级函数使用了swich语句为每个运算符赋值优先级,方便在计算过程中直接调用。也建立了运算函数对每个运算符做特定的运算,也是使用了swich语句。 另外,最后为了能够识别一些错误,在运算过程中加入了错误的判定,比如出栈时栈空或者左右符号不符等。在编写过程中发现数栈的看栈顶没有使用过,所以删除了数栈的看栈顶。

    展开全文
  • c语言逗号表达式的运算规则 c语言逗号表达式是由左向右进行的:k=3*2=6,K+2=8,表达式返回8。...(1) 逗号表达式的运算过程为:从左往右逐个计算表达式。 (2) 逗号表达式作为一个整体,它的值为最后一个
  • 用两种方式实现表达式计算,包括整数,小数,括号等的运算。
  • 接下来就为大家讲解一下这份由iMindMap制作的C语言表达式思维导图。C语言表达式一共有五块内容。一、算术运算符顾名思义,算术运算符就是我们在进行算式计算时使用到的运算符。图片1:算术运算符在C语言中,根据参与...

    1f4901e7a4a44bdba3ebb58c3df8aed8.png

    思维导图是我们在学习和了解事物,尤其是新知识时的一个好工具。比如最近我在学习的C语言课程,知识点零碎且乱,但使用思维导图就可以简单直白地总结这些零碎的内容。

    接下来就为大家讲解一下这份由iMindMap制作的C语言表达式思维导图。

    C语言表达式一共有五块内容。

    一、算术运算符

    顾名思义,算术运算符就是我们在进行算式计算时使用到的运算符。

    9b3ae6b0f9b23cd08646c6adcb79387d.png
    图片1:算术运算符

    在C语言中,根据参与运算的操作数个数分为一元运算符和二元运算符,表示参与运算的有一个或两个操作数。

    一元算术运算符就是在数值前面带上正号或负号;二元算术运算符就是我们常说的加减乘除以及除数取余。一元运算符不常使用,二元运算符在使用过程中各有各的注意事项,在导图中可以清晰地列出来。

    二、赋值运算符

    赋值运算符就是将一个数赋值给另一个数,这里要注意的是这里的表达式具有方向性,即右边赋于左边,并且左操作数必须是左值。

    8b4e8b6bd92548e2bdc090399aa1e80a.png
    图片2:赋值运算符

    赋值包括简单赋值、多重赋值和复合赋值。在简单赋值v=e这个表达式中,实际包含两个步骤,首先是将e的值计算出来,然后是将该值赋予v。多重赋值属于右结合运算,即从右侧开始逐一向左侧赋值。

    复合赋值则是将其他类型的运算符,比如算术运算符,与简单赋值运算符结合使用。

    三、自增和自减运算符

    自增和自减运算是指在数值本身的基础上加一或减一的运算,每个运算符可以进行一次加一或减一操作。

    719973bb706a781d3fafda444671c401.png
    图片3:自增和自减运算符

    其中包括后缀和前缀两种形式,它们的主要区别在于后缀使用的是在本条语句的第一步执行,即优先于其他运算符;而前缀使用是在本条语句的最后一步才会执行,即先执行其他运算再进行自增或自减运算。

    四、表达式求值

    bff8f473a7fd6619c8799c1aece528dc.png
    图片4:表达式求值

    这里的表达式求值趋向于求复合表达式,即拥有多个运算符的表达式的值。各个运算符有相对的优先级,在C语言中会根据特定的优先级和结合性来计算。

    优先级和结合性在表中已均列出,这个需要自行记忆。

    五、表达式语句

    2b82c19738557ed21ed88c47b75267ea.png
    图片5:表达式语句

    表达式和语句并不是等同的,但在编写C语言程序时,我们需要将表达式转换为语句,转换方式为在表达式后添加“;”。如果没有在其后添加分号,则会出现编译报错的现象。

    这些就是C语言表达式中的基础内容,下面附上完整的思维导图。

    2e5020db0047c949e9c648f2f22bf02f.png
    图片6:C语言表达式思维导图

    如果您也有这样的需要,欢迎进入官网下载使用iMindMap制作属于自己的思维导图。

    展开全文
  • 编写完整程序,将中缀表达式翻译成后缀表达式表达式由操作数 ( 变量 ) 、操作 ( 运算符 ) 以及小括弧 “ ( ” 和 “ ) ” 组成,其中: 1)操作包括算术运算、关系运算和逻辑运算三类; 2)操作数为单个字符或...
  • float Calculate(float prev) //表达式计算 { stack data; //存储数字的栈 stack operator; //存储字符的栈 assert(Init_Stack(&data) == true); assert(Init_Stack(&operator) == true); memset(chars, 0, ...
  • C语言逗号表达式

    千次阅读 2018-11-28 14:12:46
    c语言提供一种特殊的运算符,逗号运算符,优先级别最低,它将两个及其以上的式子联接起来,从左往右逐个计算表达式,整个表达式的值为最后一个表达式的值 #include &lt;stdio.h&gt; #include &lt;stdlib...
  • // 开始按照逆波兰计算结果 RpnNode *caclHead; caclHead = (RpnNodeList)malloc(sizeof(RpnNode)); caclHead->next = NULL; tmpStruct = (RpnNodeList)malloc(sizeof(RpnNode)); tmpStruct->next = NULL; ...
  • C语言中缀表达式

    2012-06-29 01:32:36
    计算中缀表达式的值,用到了树,堆栈的概念,是一次上机实验作业
  •   之前一个好兄弟问我表达式计算的一个程序,这个主要锻炼栈的使用。但是他向我提出了一个问题,如果多位数计算,好像常规的表达式转化就不灵了。即常规的程序只能计算10以下的数字,对于这个问题进行下探索。  ...
  • C语言-计算表达式

    千次阅读 2019-02-01 19:17:09
    //计算表达式 #include&lt;stdio.h&gt; #include&lt;ctype.h&gt; #include&lt;stdlib.h&gt; #define MAX_SIZE 128 struct OP { int type;//0 union{char symbol;double val;}value;//...
  • C语言中,将中缀表达式转成后缀表达式,并计算它的结果,具体的思路如下: 1、定义两个栈,numStack用于存放运算对象,最后存放运算结果的,fuStack用于存放运算符号的 2、从左到右遍历字符串 3、如果当前的字符是...
  • C语言计算前缀表达式

    2019-10-06 21:11:22
    请设计程序计算前缀表达式的结果值。 输入格式: 输入在一行内给出不超过30个字符的前缀表达式,只包含+、-、*、\以及运算数,不同对象(运算数、运算符号)之间以空格分隔。 输出格式: 输出前缀表达...
  • C语言表达式与语句

    千次阅读 2015-08-06 06:04:22
    C语言中,表达式是显示如何计算值的公式。语句是C语言的关键特性之一,表示程序运行时执行的命令。本文介绍并示例了C语言中的表达式和语句
  • C语言练习 表达式的递归计算

    千次阅读 2014-03-25 22:47:45
    在1 2 3 4 5 6 7 8 9 之间的8个空之间填入“+”“-”“ ”三种,使表达式的值为110。比如1 2之间填入的是“ ”,则他们成为12。8个都是“ ”则表达式的值为123456789。 输出所有的情况,使表达式的值为110。 #...
  • C语言后缀表达式计算--For初学者

    千次阅读 2018-09-26 20:19:25
    上次写了中缀转后缀,这次来计算后缀表达式的值,书接上文click here。 思路很简单,先扫描输入的后缀表达式,遇到数字就进栈,遇到运算符就出两个栈顶的元素运算,运算的结果再入栈。直到扫描完,并且栈内只剩下一...
  • 计算下面数学表达式的值:cos3.56+log1035+ln8.56+e2.63+tan0.78 输入:无。 输出:表达式的值。
  • 150. 逆波兰表达式求值根据 逆波兰表示法,求表达式的值。有效的运算符包括 + , - , * , / 。每个运算对象可以是整数,也可以是另一个逆波兰表达式。说明:整数除法只保留整数部分。给定逆波...
  • C语言后缀表达式求值

    千次阅读 2018-12-16 23:06:48
    如果遇到运算符,那么弹出栈里面两个元素,先弹出的是右运算数,后弹出的是左运算数,计算运算结果,然后将结果入栈。最后遍历到后缀表达式末尾,当结果只有一个元素时,就是答案 #define _CRT_SECURE_NO_WARNINGS...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,785
精华内容 1,114
关键字:

c语言计算表达式

c语言 订阅