C traps and defects Chapter 3 semantic "traps" 3.7 evaluation order

Order of evaluation
The problem of operator priority is completely different from the evaluation order .
Operator precedence such as expression  
a + b * c
It should be interpreted as  
a + (b * c)
instead of  
(a + b) * c
Such a rule . Evaluation order is another kind of rule , You can guarantee the following statements  
if (count != 0 && sum/count < smallaverage) {
    printf("average < %g\n", smallaverage);
}
Even when the variable count by 0 when , Nor will it produce a “ use 0 Do divisor ” Error of . 
a < b && c < d
C The definition of language States a<b Should be evaluated first . If a It's really less than b, At this time, we must further study c<d evaluation , To determine the value of the entire expression . however , If a Greater than or equal to b, Then there is no need to c<d evaluation , The expression must be false . 
in addition , Right a<b evaluation , The compiler may first correct a evaluation , Maybe first b evaluation , On some machines, it is even possible to evaluate them in parallel at the same time .
C There is only... In the language 4 Operators （&&、||、?: and ,） There is a specified order of evaluation . Operator || And operators && First, evaluate the left-hand operand , The right-hand operands are evaluated only if necessary . Operator ?: Yes 3 Operands ： stay a?b:c in , Operands a First evaluated , according to a And then find the operand b or c Value . The comma operator first evaluates the left operand , then “ discarded ” This value , Then evaluate the right-hand operands .
Comma expressions that separate function parameters are not comma operators .f(x, y) in x and y The evaluation order of is uncertain ,g((x, y)) The evaluation order of is first x Value , Throw it away , Ask again y Value . function g There is only one parameter . 
C The order in which all other operators in the language evaluate their operators is undefined . especially , Assignment operators do not guarantee any evaluation order .
Operator && And operators || It is very important to ensure that the inspection operations are carried out in the correct order , for example , In statement  
if (y != 0 &&  x/y > tolerance) 
    conplain();
in , We must ensure that we do our best y Not 0 The time is right x/y evaluation . 
//no guarantee
From an array x Before assignment in n Elements to arrays y The practice in is incorrect , Because it makes too many assumptions about the evaluation order ： 
i = 0;
while (i < n) {
    y[i] = x[i++];
}
The problem lies in the code assumption above y[i] The address of will be at i The auto increment operation of is evaluated before execution , There is no guarantee of this ！ 
//also no guarantee
The following version is written in a similar way , It's not true either ： 
i = 0;
while (i < n) {
    y[i++] = x[i];
}
//can be guaranteed
The following way of writing works correctly ： 
i = 0;
while (i < n) {
    y[i] = x[i];
    i++;
}
I could just write it as ： 
for (i = 0; i < n; i++) {
    y[i] = x[i];
}