C语言中的算子优先与结合性-yiteyi-C++库

运算符优先级 确定在具有多个具有不同优先级的运算符的表达式中首先执行哪个运算符。 例如： 解决

null

10 + 20 * 30

图片[1]-C语言中的算子优先与结合性-yiteyi-C++库

10 + 20 * 30 is calculated as 10 + (20 * 30)and not as (10 + 20) * 30

算子结合性 当一个表达式中出现两个具有相同优先级的运算符时使用。关联性可以是 L eft T o R 是吗 R 嗯 T o L eft。 例如： “*”和“/”具有相同的优先级，它们的关联性为 L eft T o R 是的，所以表达式“100/10*10”被视为“（100/10）*10”。

图片[2]-C语言中的算子优先与结合性-yiteyi-C++库

运算符优先级和结合性是运算符的两个特征，它们决定了在没有括号的情况下子表达式的求值顺序

例如： 解决

100 + 200 / 10 - 3 * 10

图片[3]-C语言中的算子优先与结合性-yiteyi-C++库

1）只有当有两个或多个具有相同优先级的运算符时，才使用关联性。 需要注意的是，结合性并不定义单个运算符的操作数的求值顺序。例如，考虑下面的程序，+运算符的关联性是左到右的，但并不意味着f1（）总是在f2（）之前调用。以下程序的输出实际上依赖于编译器。看见这详细信息。

C

                         // Associativity is not used in the below program.                       
                         // Output is compiler dependent.                       
           
                         #include <stdio.h>                       
           
                         int                                     x = 0;                       
                         int                                     f1()                       
                         {                       
                                                 x = 5;                       
                                                 return                                     x;                       
                         }                       
                         int                                     f2()                       
                         {                       
                                                 x = 10;                       
                                                 return                                     x;                       
                         }                       
                         int                                     main()                       
                         {                       
                                                 int                                     p = f1() + f2();                       
                                                 printf                                     (                                     "%d "                                     , x);                       
                                                 return                                     0;                       
                         }                       

2）所有具有相同优先级的运算符都具有相同的关联性 这是必要的，否则，编译器将无法决定具有相同优先级和不同结合性的两个运算符的表达式的求值顺序。例如+和–具有相同的关联性。 3）后缀++和前缀++的优先级和关联性是不同的 后缀++的优先级比前缀++高，它们的关联性也不同。后缀++的关联性是从左到右，前缀++的关联性是从右到左。看见这例如。 4）逗号在所有运算符中的优先级最低，应谨慎使用 例如，考虑下面的程序，输出为1。看见这和这更多细节。

C

                         #include <stdio.h>                       
                         int                                     main()                       
                         {                       
                                                 int                                     a;                       
                                                 a = 1, 2, 3;                                     // Evaluated as (a = 1), 2, 3                       
                                                 printf                                     (                                     "%d"                                     , a);                       
                                                 return                                     0;                       
                         }                       

5） C语言中没有比较运算符的链接 在Python中，像“C> B> A”这样的表达式被称为“C＞B和B＞A”，但是这种类型的链接在C.没有发生，例如考虑下面的程序。以下程序的输出为“假”。

C

                         #include <stdio.h>                       
                         int                                     main()                       
                         {                       
                                                 int                                     a = 10, b = 20, c = 30;                       
           
                                                 // (c > b > a) is treated as ((c  > b) > a), associativity of '>'                       
                                                 // is left to right. Therefore the value becomes ((30 > 20) > 10)                       
                                                 // which becomes (1 > 10)                       
                                                 if                                     (c > b > a)                       
                                                 printf                                     (                                     "TRUE"                                     );                       
                                                 else                       
                                                 printf                                     (                                     "FALSE"                                     );                       
                                                 return                                     0;                       
                         }                       

请参见以下优先级和关联性表以供参考。

操作人员	描述	结合性
( ) [ ] . -> ++ – –	括号（函数调用）（见注1）括号（数组下标）通过对象名称选择成员通过指针选择成员后缀增量/减量（见注2）	从左到右
++ – – + – ! ~ ( 类型 ) * & sizeof	前缀递增/递减一元加减逻辑否定/位补码强制转换（将值转换为类型 ) 解引用（操作数的）地址确定此实现的大小（以字节为单位）	从右向左
* / %	乘/除/模	从左到右
+ –	加减法	从左到右
<>	按位左移，按位右移	从左到右
> >=	关系小于/小于或等于关系大于/大于或等于	从左到右
== !=	关系等于/不等于	从左到右
&	按位与	从左到右
^	位异或	从左到右
\|	按位包含或	从左到右
&&	逻辑与	从左到右
\| \|	逻辑或	从左到右
? :	三元条件	从右向左
= += -= *= /= %= &= ^= \|= <<= >>=	分配加减作业乘法/除法赋值模/位与赋值按位独占/包含或赋值按位左/右移位赋值	从右向左
,	逗号（单独的表达式）	从左到右

了解优先级和关联性规则很好，但最好是使用括号，尤其是对于不太常用的运算符（除+、-、*…等以外的运算符）。括号增加了代码的可读性，因为读者不必查看表格来找出顺序。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写评论

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章