运算符优先级问题

whyglinux

>> 请看我的举例,在这种情况下,是不是不按优先级一一运算了

在C/C++中，本来（操作数的）计算顺序就不是由（运算符的）优先级来决定的。运算符的优先级和结合性只是决定了操作数“组合”的顺序。例如： a+b-c*d 是表明了这样一种运算： (a+b)-(c*d)，而不是 a+(b-c)*d 或者其它组合形式。

至于真正的运算顺序，由于C/C++标准都没有规定，所以是不确定的。例如对于表达式  a+b-c*d 中的减号运算符 - 来说，无法确定它的两个操作数 a+b 和 c*d 到底哪一个先被计算，这与运算符的优先级没有直接关系。

但是标准规定了四个运算符的运算顺序，它们是：逻辑与&&、逻辑或||、 逗号, 和条件运算符?:，规定这些运算符的操作数按照从左到右的顺序进行；并且对于 && 和 || 还根据逻辑运算的特点特别规定：如果从左边的操作数的计算已经可以判定逻辑结果的话，右面的操作数将不被计算。

上面 trueno 说的是正确的，不知道为什么 flw 有不同意见啊?

honkily

逻辑与&&、逻辑或||的运算顺序书本上讲的有～

erduo100

++a||++b&&++c
等价于++a||(++b&&++c)
但先计算++a，由于a==2 不为0并根据short-circuit evaluation
故不再进行(++b&&++c)
即 a = 2;b =2 ; c= 1;

flw

原帖由 whyglinux 于 2005-10-31 21:11 发表
上面 trueno 说的是正确的，不知道为什么 flw 有不同意见啊?

C++ 的语法我没有看过权威资料，对标准不是很熟。
但是 C 的语法在我的记忆中一直都是对 && 和 || 的求值顺序没有规定。
今天又特意找到了一段资料，
可惜我的英文并不是很过关，因此发上来请兄台和我一起参祥参祥：

       [#3]  The grouping of operators and operands is indicated by |
       the syntax.59)  Except as specified later (for the function- |
       call  (),  &&,  ||,  ?:,  and comma operators), the order of
       evaluation of subexpressions and the  order  in  which  side
       effects take place are both unspecified.

.....

       59)The syntax specifies the precedence of operators  in  the
          evaluation  of  an  expression,  which is the same as the
          order of the major subclauses of this subclause,  highest
          precedence  first.   Thus,  for  example, the expressions
          allowed as the operands of the binary + operator  (6.5.6) |
          are  those  expressions  defined  in 6.5.1 through 6.5.6.
          The exceptions are cast expressions (6.5.4)  as  operands
          of  unary  operators  (6.5.3),  and  an operand contained
          between any of the following pairs of operators: grouping
          parentheses   ()   (6.5.1),   subscripting   brackets  []
          (6.5.2.1), function-call parentheses  ()  (6.5.2.2),  and
          the conditional operator ?: (6.5.15).

          Within  each major subclause, the operators have the same
          precedence.  Left- or right-associativity is indicated in
          each   subclause   by  the  syntax  for  the  expressions
          discussed therein.

原文出处：
http://www.open-std.org/jtc1/sc22/wg14/www/docs/n843.htm

win_hate

[#3]  The grouping of operators and operands is indicated by |
       the syntax.59)  Except as specified later (for the function- |
       call  (),  &&,  ||,  ?:,  and comma operators), the order of
       evaluation of subexpressions and the  order  in  which  side
       effects take place are both unspecified.

简化为:

Except as specified later (xxx), the order of
       evaluation of subexpressions and the  order  in  which  side
       effects take place are both unspecified.

即除非特别说明的，其求值次序是不确定的。而要特别说明的就是括号中的 xxx，其中包括  ||  和 &&.

flw

原帖由 win_hate 于 2005-11-1 10:40 发表


简化为:


即除非特别说明的，其求值次序是不确定的。而要特别说明的就是括号中的 xxx，其中包括  ||  和 &&.

刚才又找到下面这一段描述，写得比较清楚。果然如同你和 whyglinux 二位所说。

6.5.13  Logical AND operator

       Syntax

       [#1]

               logical-AND-expr:
                       inclusive-OR-expr
                       logical-AND-expr && inclusive-OR-expr

       Constraints

       [#2] Each of the operands shall have scalar type.

       Semantics

       [#3]  The  && operator shall yield 1 if both of its operands
       compare unequal to 0; otherwise, it yields  0.   The  result
       has type int.

       [#4]  Unlike  the bitwise binary & operator, the && operator
       guarantees left-to-right evaluation;  there  is  a  sequence
       point  after  the  evaluation  of the first operand.  If the
       first operand compares equal to 0, the second operand is not
       evaluated.

       6.5.14  Logical OR operator

       Syntax

       [#1]

               logical-OR-expr:
                       logical-AND-expr
                       logical-OR-expr || logical-AND-expr

       Constraints

       [#2] Each of the operands shall have scalar type.

       Semantics

       [#3] The || operator shall yield 1 if either of its operands
       compare unequal to 0; otherwise, it yields  0.   The  result
       has type int.

       [#4]   Unlike  the  bitwise  |  operator,  the  ||  operator
       guarantees left-to-right evaluation;  there  is  a  sequence
       point  after  the  evaluation  of the first operand.  If the
       first operand compares unequal to 0, the second  operand  is
       not evaluated.

renstone921

逻辑与&&的优先级要比||的优先级要高。