zoukankan      html  css  js  c++  java
  • C语言运算符摘录

    优先级

    运算符

    名称或含义

    使用形式

    结合方向

    说明

    1

    []

    数组下标

    数组名[常量表达式]

    左到右

    ()

    圆括号

    (表达式)/函数名(形参表)=

    .

    成员选择(对象)

    对象.成员名

    ->

    成员选择(指针)

    对象指针->成员名

    2

    -

    负号运算符

    -表达式

    右到左

    单目运算符

    (类型)

    强制类型转换

    (数据类型)表达式

    ++

    自增运算符

    ++变量名/变量名++

    单目运算符

    --

    自减运算符

    --变量名/变量名--

    单目运算符

    *

    取值运算符

    *指针变量

    单目运算符

    &

    取地址运算符

    &变量名

    单目运算符

    !

    逻辑非运算符

    !表达式

    单目运算符

    ~

    按位取反运算符

    ~表达式

    单目运算符

    sizeof

    长度运算符

    sizeof(表达式)

    3

    /

    表达式/表达式

    左到右

    双目运算符

    *

    表达式*表达式

    双目运算符

    %

    余数(取模)

    整型表达式/整型表达式

    双目运算符

    4

    +

    表达式+表达式

    左到右

    双目运算符

    -

    表达式-表达式

    双目运算符

    5

    <<

    左移

    变量<<表达式

    左到右

    双目运算符

    >>

    右移

    变量>>表达式

    双目运算符

    6

    >

    大于

    表达式>表达式

    左到右

    双目运算符

    >=

    大于等于

    表达式>=表达式

    双目运算符

    <

    小于

    表达式<表达式

    双目运算符

    <=

    小于等于

    表达式<=表达式

    双目运算符

    7

    ==

    等于

    表达式==表达式

    左到右

    双目运算符

    !=

    不等于

    表达式!= 表达式

    双目运算符

    8

    &

    按位与

    表达式&表达式

    左到右

    双目运算符

    9

    ^

    按位异或

    表达式^表达式

    左到右

    双目运算符

    10

    |

    按位或

    表达式|表达式

    左到右

    双目运算符

    11

    &&

    逻辑与

    表达式&&表达式

    左到右

    双目运算符

    12

    ||

    逻辑或

    表达式||表达式

    左到右

    双目运算符

    13

    ?:

    条件运算符

    表达式1? 表达式2: 表达式3

    右到左

    三目运算符

    14

    =

    赋值运算符

    变量=表达式

    右到左

    /=

    除后赋值

    变量/=表达式

    *=

    乘后赋值

    变量*=表达式

    %=

    取模后赋值

    变量%=表达式

    +=

    加后赋值

    变量+=表达式

    -=

    减后赋值

    变量-=表达式

    <<=

    左移后赋值

    变量<<=表达式

    >>=

    右移

    后赋值

    变量>>=表达式

    &=

    按位与后赋值

    变量&=表达式

    ^=

    按位异或后赋值

    变量^=表达式

    |=

    按位或后赋值

    变量|=表达式

    15

    ,

    逗号运算符

    表达式,表达式,…

    左到右

    从左向右顺序运算

    说明:

    同一优先级的运算符,运算次序由结合方向所决定。

    由于C语言中运算符多,优先级复杂,难以记忆,针对上述运算符,我们可以归纳成几名口诀,以便于记忆:

    优先级口诀

    括号成员第一;              括号运算符[]() 成员运算符. ->

    全体单目第二;              所有的单目运算符比如++ -- +(正) -(负) 指针运算*&

    乘除余三,加减四;         这个"余"是指取余运算即%

    移位五,关系六;           移位运算符:<< >> ,关系:> < >= <= 等

    等于(与)不等排第七;    即== !=

    位与异或和位或;          这几个都是位运算: 位与(&)异或(^)位或(|)

    "三分天下"八九十;

    逻辑或跟与;                 逻辑运算符:|| 和 &&

    十二和十一;                 注意顺序:优先级(||) 底于 优先级(&&)

    条件高于赋值,                三目运算符优先级排到 13 位只比赋值运算符和","高

    逗号运算级最低!         逗号运算符优先级最低

    //强制类型转换运算符 (数据类型)
    //++ -- 自增自减运算符
    //算术运算符: * / % + -
    //关系运算符: > >= < <= == !=
    //逻辑运算符:  && || !
    //条件运算符(三目运算符) ?:
    //赋值运算符: = /= *= %= += -=
    //逗号运算符: ,
    
    //表达式: 由运算符,常量,变量组成的一个式子;
    //表达式有确定数据类型跟值
    #include <stdio.h>
    int main(int argc, const char * argv[]) {
        printf("%.2f
    ",3.14*5*5);
        printf("%d
    ", 56*67);
        int a=10;
        int b= 20;
        printf("a+b = %d
    ", a+b);
        
        return 0;
    }
    
    //自增自减运算符
    //++ --
    
    int main(int argc,const char *argv[])
    {
        int a=10;
        int b=20;
        printf("a= %d b= %d
    ", a++,b--);//a++ <==> a=a+1
        //在语句执行完毕后, 变化 a b的值
        printf("a = %d b = %d
    ", a, b);
        //在语句执行前,变化a, b的值
        
        printf("a= %d b= %d
    ", ++a, --b);
        
        //printf("a= %d b= %d
    ", (++a + a++),--b);//a的值未定义的, 在一条C语言语句中 变量的值不能被多次修改
        
        //printf("b = %d
    ", --b + --b);
        return 0;
    }
    
    //算术运算符: * / % + -
    
    int main(int argc,const char *argv[])
    {
        int a=10, b=20;
        printf("a*b = %d
    ", a*b);
        printf("a/b = %d
    ", a/b);
        printf("a%%b = %d
    ", a%b);//%d %f %ld  %% 输出一个% 第一个%用来转义
        
        printf("a+b = %d
    ", a+b);
        printf("a-b = %d
    ", a-b);
        printf("value = %d
    ", a%b*a);
        return 0;
    }
    
    //关系运算符: > >= < <= == !=
    int main(int argc,const char *argv[])
    {
        int a = 10, b= 20;
        printf("val = %d
    ",a>b);
        printf("val = %d
    ",a<b);
        
        printf("(a>=b) = %d
    ", a>=b);
        printf("(a<=b) = %d
    ", a<=b);
        printf("(a==b) = %d
    ", a==b);
        printf("(a!=b) = %d
    ", a!=b);
    
        return 0;
    }
    
    //逻辑运算符:  && || !
    //&& (逻辑与 逻辑乘)
    //表达式1   表达式2  ... 表达式n   整个表达式
    //真         真                   真
    //假         真                   假
    //真         假                   假
    //假         假                   假
    //结论: 对于逻辑与, 表达式中有一个表达式为假, 那么整个表达式的值为假
    
    
    //|| (逻辑或 逻辑加)
    //表达式1    表达式2      整个表达式
    // 真          真         真
    // 假          真         真
    //真             假       真
    //假             假       假
    //结论: 对于逻辑加, 只要有一个表达式为真, 那么整个表达式的值为真
    
    // ! (逻辑非)
    //0 为假  !0 为真
    //表达式     整个表达式
    //真         假
    //假         真
    
    
    int main(int argc, const char *argv[])
    {
        int a= 0;
        int b= 20;
        printf("a&&b = %d
    ", a&&b);
        printf("a||b = %d
    ", a||b);
        printf("!a = %d
    ", !a);
        
        return 0;
    }
    
    //条件运算符(三目运算符) ?:
    //表达式?表达式1:表达式2
    //如果表达式的值为真, 整个表达式的值是表达式1的值 否则是表达式2的值
    
    //宏定义一个函数
    #define min(a,b) ((a<b)?(a):(b))
    #define max(a,b) ((a>b)?(a):(b))
    #define min2(a,b,c) ((((a<b)?(a):(b))<c)?((a<b)?(a):(b)):c)
    
    int main(int argc, const char *argv[])
    {
        int a=5;
        int b=20;
        int c=10;
        printf("val = %d
    ", a<b?a:b);
        printf("min = %d
    ", min(a, b));
        printf("max = %d
    ", max(a, b));
        printf("min2 = %d
    ", min2(a, b, c) );
        return 0;
    }
    
    //赋值运算符: = /= *= %= += -=
    
    int main(int argc,const char *argv[])
    {
        int a=20;//
        int b=10;
        //a = 10;
        printf("a= %d
    ", a);
        printf("(a/=b) = %d
    ", a/=b);//<==> a = a/b
        //a=2
        printf("(a*=b) = %d
    ", a*=b);//<==> a= a*b
        //a=20
        printf("(a%%=b) = %d
    ", a%=b);//<==> a= a%b;
        //a=0;
        printf("(a+=b) = %d
    ", a+=b);//<==> a= a+b;
        //a= 10;
        printf("(a-=b) = %d
    ", a-=b); //<==> a= a-b;
        
        return 0;
    }
    
    //逗号运算符: ,
    //表达式1,表达式2,表达式3,表达式4,.......表达式n
    //整个表达式值是表达式n的值
    int main(int argc,const char *argv[])
    {
        int a=20;
        int b=10;
        int c=30;
        int d=40;
        printf("val = %d
    ", (c=a+b,d=a-b,a*b));
    
        return 0;
    }
    
    //运算符优先级
    //括号 > 单目运算符 > 算术运算符(* / % 大于 + -) > 关系运算符 (> >= < <= 大于 == !=) > && >|| >条件运算符 > 赋值运算符 > 逗号运算符
    
    //加括号提高表达式的优先级
    
    int main(int argc,const char *argv[])
    {
        int a=10;
        float f=3.14;
        printf("val = %f
    ", a+f);//隐式转换
    
        printf("val = %d
    ", a+(int)f);//截断
        printf("val = %d
    ", (int)(a+f));//显示转换(强制类型转换)
        
        char ch = -34;
        int num = 2045678;
        printf("value = %d 
    ", ch + num);//char --> int
        //位扩展 对于正数, 高位补0 , 对于负数高位补1
        return 0;
    }
    
    //结论:1. 浮点类型数据跟整型数据运算, 把整型数据提升成浮点类型数据
    //2. 对于整型数据 char short 向 int long  long long类型看齐
    //3.只有char short类型数据运算, char short 向int类型看齐
    //4.float 向 double  long double类型看齐
    //5.有符号类型数据向无符号类型数据看齐
    
  • 相关阅读:
    [Luogu P3626] [APIO2009] 会议中心
    杭电 1869 六度分离 (求每两个节点间的距离)
    杭电 1874 畅通工程续 (求某节点到某节点的最短路径)
    最短路径模板
    杭电 2544 最短路径
    POJ 1287 Networking (最小生成树模板题)
    NYOJ 1875 畅通工程再续 (无节点间距离求最小生成树)
    POJ 2485 Highways (求最小生成树中最大的边)
    杭电 1233 还是畅通工程 (最小生成树)
    杭电 1863 畅通工程 (最小生成树)
  • 原文地址:https://www.cnblogs.com/sublimter/p/4161215.html
Copyright © 2011-2022 走看看