zoukankan      html  css  js  c++  java
  • 运算符优先级

    https://baike.baidu.com/item/运算符优先级/4752611?fr=aladdin

    优先级

    编辑
    优先级从上到下依次递减,最上面具有最高的优先级,逗号操作符具有最低的优先级。
    相同优先级中,按结合顺序计算。大多数运算是从左至右计算,只有三个优先级是从右至左结合的,它们是单目运算符条件运算符赋值运算符
    基本的优先级需要记住:
    指针最优,单目运算优于双目运算。如正负号。
    先算术运算,后移位运算,最后位运算。请特别注意:1 << 3 + 2 & 7等价于 (1 << (3 + 2))&7.
    逻辑运算最后计算。

    C语言优先级

    编辑
    优先级
    运算符
    名称或含义
    使用形式
    结合方向
    说明
    1
    []
    数组下标
    数组名[整型表达式]
    左到右
     
    ()
    圆括号
    (表达式)/函数名(形参表)
     
    .
    成员选择(对象)
    对象.成员名
     
    ->
    成员选择(指针)
    对象指针->成员名
     
    2
    -
    负号运算符
    -算术类型表达式
    右到左
    单目运算符
    (type)
    强制类型转换
    (纯量数据类型)纯量表达式
     
    ++
    自增运算符
    ++纯量类型可修改左值表达式
    单目运算符
    --
    自减运算符
    --纯量类型可修改左值表达式
    单目运算符
    *
    取值运算符
    *指针类型表达式
    单目运算符
    &
    取地址运算符
    &表达式
    单目运算符
    !
    逻辑非运算符
    !纯量类型表达式
    单目运算符
    ~
    按位取反运算符
    ~整型表达式
    单目运算符
    sizeof
    长度运算符
    sizeof 表达式
    sizeof(类型)
     
    3
    /
    表达式/表达式
    左到右
    双目运算符
    *
    表达式*表达式
    双目运算符
    %
    余数(取模)
    整型表达式%整型表达式
    双目运算符
    4
    +
    表达式+表达式
    左到右
    双目运算符
    -
    表达式-表达式
    双目运算符
    5
    <<
    左移
    整型表达式<<整型表达式
    左到右
    双目运算符
    >>
    右移
    整型表达式>>整型表达式
    双目运算符
    6
    >
    大于
    表达式>表达式
    左到右
    双目运算符
    >=
    大于等于
    表达式>=表达式
    双目运算符
    <
    小于
    表达式<表达式
    双目运算符
    <=
    小于等于
    表达式<=表达式
    双目运算符
    7
    ==
    等于
    表达式==表达式
    左到右
    双目运算符
    !=
    不等于
    表达式!= 表达式
    双目运算符
    8
    &
    按位与
    整型表达式&整型表达式
    左到右
    双目运算符
    9
    ^
    按位异或
    整型表达式^整型表达式
    左到右
    双目运算符
    10
    |
    按位或
    整型表达式|整型表达式
    左到右
    双目运算符
    11
    &&
    逻辑与
    表达式&&表达式
    左到右
    双目运算符
    12
    ||
    逻辑或
    表达式||表达式
    左到右
    双目运算符
    13
    ?:
    条件运算符
    表达式1? 表达式2: 表达式3
    右到左
    三目运算符
    14
    =
    赋值运算符
    可修改左值表达式=表达式
    右到左
     
    /=
    除后赋值
    可修改左值表达式/=表达式
     
    *=
    乘后赋值
    可修改左值表达式*=表达式
     
    %=
    取模后赋值
    可修改左值表达式%=表达式
     
    +=
    加后赋值
    可修改左值表达式+=表达式
     
    -=
    减后赋值
    可修改左值表达式-=表达式
     
    <<=
    左移后赋值
    可修改左值表达式<<=表达式
     
    >>=
    右移后赋值
    可修改左值表达式>>=表达式
     
    &=
    按位与后赋值
    可修改左值表达式&=表达式
     
    ^=
    按位异或后赋值
    可修改左值表达式^=表达式
     
    |=
    按位或后赋值
    可修改左值表达式|=表达式
     
    15
    ,
    逗号运算符
    表达式,表达式,…
    左到右
    从左向右顺序结合
    说明:
    同一优先级的运算符,结合次序由结合方向所决定。
    简单记就是:! > 算术运算符 > 关系运算符 > && > || > 赋值运算符

    C++

    编辑
    运算符
    描述
    例子
    可重载性
    第一级别
         
    ::
    作用域解析符
    Class::age = 2;
    不可重载
    第二级别
         
    ()
    函数调用
    isdigit('1')
    可重载
    ()
    成员初始化
    c_tor(int x, int y) : _x(x), _y(y*10){};
    可重载
    []
    数组数据获取
    array[4] = 2;
    可重载
    ->
    指针型成员调用
    ptr->age = 34;
    可重载
    .
    对象型成员调用
    obj.age = 34;
    不可重载
    ++
    后自增运算符
    for( int i = 0; i < 10; i++ ) cout << i;
    可重载
    --
    后自减运算符
    for( int i = 10; i > 0; i-- ) cout << i;
    可重载
    const_cast
    特殊属性转换
    const_cast<type_to>(type_from);
    不可重载
    dynamic_cast
    特殊属性转换
    dynamic_cast<type_to>(type_from);
    不可重载
    static_cast
    特殊属性转换
    static_cast<type_to>(type_from);
    不可重载
    reinterpret_cast
    特殊属性转换
    reinterpret_cast<type_to>(type_from);
    不可重载
    typeid
    对象类型符
    cout &laquo; typeid(var).name();
    cout &laquo; typeid(type).name();
    不可重载
    第三级别(具有右结合性)
         
    !
    逻辑取反
    if( !done ) …
    可重载
    not
    ! 的另一种表达
       
    ~
    按位取反
    flags = ~flags;
    可重载
    compl
    ~的另一种表达
       
    ++
    预自增运算符
    for( i = 0; i < 10; ++i ) cout << i;
    可重载
    --
    预自减运算符
    for( i = 10; i > 0; --i ) cout << i;
    可重载
    -
    负号
    int i = -1;
    可重载
    +
    正号
    int i = +1;
    可重载
    *
    指针取值
    int data = *intPtr;
    可重载
    &
    值取指针
    int *intPtr = &data;
    可重载
    new
    动态元素内存分配
    long *pVar = new long;
    MyClass *ptr = new MyClass(args);
    可重载
    new []
    动态数组内存分配
    long *array = new long[n];
    可重载
    delete
    动态析构元素内存
    delete pVar;
    可重载
    delete []
    动态析构数组内存
    delete [] array;
    可重载
    (type)
    强制类型转换
    int i = (int) floatNum;
    可重载
    sizeof
    返回类型内存
    int size = sizeof floatNum;
    int size = sizeof(float);
    不可重载
    第四级别
         
    ->*
    类指针成员引用
    ptr->*var = 24;
    可重载
    .*
    类对象成员引用
    obj.*var = 24;
    不可重载
    第五级别
         
    *
    乘法
    int i = 2 * 4;
    可重载
    /
    除法
    float f = 10.0 / 3.0;
    可重载
    %
    取余数(模运算)
    int rem = 4 % 3;
    可重载
    第六级别
         
    +
    加法
    int i = 2 + 3;
    可重载
    -
    减法
    int i = 5 - 1;
    可重载
    第七级别
         
    <<
    位左移
    int flags = 33 << 1;
    可重载
    >>
    位右移
    int flags = 33 >> 1;
    可重载
    第八级别
         
    <
    小于
    if( i < 42 ) …
    可重载
    <=
    小于等于
    if( i <= 42 ) ...
    可重载
    >
    大于
    if( i > 42 ) …
    可重载
    >=
    大于等于
    if( i >= 42 ) ...
    可重载
    第九级别
         
    ==
    恒等于
    if( i == 42 ) ...
    可重载
    eq
    == 的另一种表达
       
    !=
    不等于
    if( i != 42 ) …
    可重载
    not_eq
    !=的另一种表达
       
    第十级别
         
    &
    位且运算
    flags = flags & 42;
    可重载
    bitand
    &的另一种表达
       
    第十一级别
         
    ^
    位异或运算
    flags = flags ^ 42;
    可重载
    xor
    ^的另一种表达
       
    第十二级别
         
    |
    位或运算
    flags = flags | 42;
    可重载
    bitor
    |的另一种表达
       
    第十三级别
         
    &&
    逻辑且运算
    if( conditionA && conditionB ) …
    可重载
    and
    &&的另一种表达
       
    第十四级别
         
    ||
    逻辑或运算
    if( conditionA || conditionB ) ...
    可重载
    or
    ||的另一种表达
       
    第十五级别(具有右结合性)
         
    ? :
    条件运算符
    int i = (a > b) ? a : b;
    不可重载
    第十六级别(具有右结合性)
         
    =
    赋值
    int a = b;
    可重载
    +=
    加赋值运算
    a += 3;
    可重载
    -=
    减赋值运算
    b -= 4;
    可重载
    *=
    乘赋值运算
    a *= 5;
    可重载
    /=
    除赋值运算
    a /= 2;
    可重载
    %=
    模赋值运算
    a %= 3;
    可重载
    &=
    位且赋值运算
    flags &= new_flags;
    可重载
    and_eq
    &= 的另一种表达
       
    ^=
    位异或赋值运算
    flags ^= new_flags;
    可重载
    xor_eq
    ^=的另一种表达
       
    |=
    位或赋值运算
    flags |= new_flags;
    可重载
    or_eq
    |=的另一种表达
       
    <<=
    位左移赋值运算
    flags <<= 2;
    可重载
    >>=
    位右移赋值运算
    flags >>= 2;
    可重载
    第十七级别
         
    throw
    异常抛出
    throw EClass(“Message”);
    不可重载
    第十八级别
         
    ,
    逗号分隔符
    for( i = 0, j = 0; i < 10; i++, j++ ) …
    可重载

    Java

    编辑
    运算符结合性
    [ ] . ( ) (方法调用) 从左向右
    ! ~ ++ -- +(一元运算) -(一元运算) 从右向左
    * / % 从左向右
    + - 从左向右
    << >> >>> 从左向右
    < <= > >= instanceof 从左向右
    == != 从左向右
    & 从左向右
    ^ 从左向右
    | 从左向右
    && 从左向右
    || 从左向右
    ?: 从右向左
    =
    从右向左
    一个特殊的例子:
    public class stlye
    {
    public static void main(String[] args)
    {
      int a=10,b=6;
      System.out.println("改变之前的数:a="+a+",b="+b);
      a-=b++;
      System.out.println("改变之后的数:a="+a+",b="+b);
    }
    }
    运算结果为:
    改变之前的数:a=10,b=6
    改变之后的数:a=4,b=7
    因为b++运算中先执行++,再返回后置++运算表达式(b++)的返回值(6)给-=运算符。
    在这个程序中a-=b++等于a=a-b++=10-6,所以a=4。

    C#

    编辑
    优先级
    类别
    运算符
    1
    基本
    (x) x.y f(x) a[x] x++ x-- new typeof sizeof checked unchecked
    2
    单目
    + - ! ~ ++x --x (T)x
    3
    乘法与除法
    * / %
    4
    加法与减法
    + -
    5
    移位运算
    << >>
    6
    关系运算
    < > <= >=
    7
    条件等
    == !=
    8
    位逻辑与
    &
    9
    位逻辑异或
    ^
    10
    位逻辑或
    |
    11
    条件与
    &&
    12
    条件或
    13
    条件
    ?:
    14
    赋值
    =
    一个特殊的例子:
    class Program
      {
      static void Main(string[] args)
      {
      int a; a = 10; int b = 4;
      a += b++;
    Console.WriteLine("a={0}",a);
      Console.WriteLine("b={0}", b);
      Console.ReadLine();
      }
      }
    运算结果为:
    a=14
    b=5
    在这个程序中a+=b等于a=a+b=10+4,因为 b++ 时返回了一个临时变量后才进行自增。

    Visual Basic

    编辑

    优先级
    类别
    运算符
    1
    乘方 ^
    2 取负 -
    3 *
    3 /
    4 四舍五入除/位移
    5 取模 Mod
    6 +
    6 -
    7 字符串合并 & 或 +
    8 相等 =
    8 大于 >
    8 大于等于 >=
    8 小于 <
    8 小于等于 <=
    8 不等于 <>
    8 同类对象 Is
    8 Like运算 Like
    9 Not
    10 And
    11 Or
    12 异或 Xor
    13 逻辑等 Eqv
    14 逻辑大于等于(蕴含) Imp

  • 相关阅读:
    __declspec关键字详细用法
    【转载】前端面试“http全过程”将所有HTTP相关知识抛出来了...
    【转载】理解C语言中的关键字extern
    Linux应用环境实战
    【转载】深入解析连接点
    【转载】COM多线程原理与应用
    【转载】COM的多线程模型
    【转载】COM 连接点
    【转载】COM:IUnknown、IClassFactory、IDispatch
    101. Symmetric Tree
  • 原文地址:https://www.cnblogs.com/rsapaper/p/10190731.html
Copyright © 2011-2022 走看看