&&和＆的优化行为

Question

Consider

 bool Fun1()
{
 ...
}
bool Fun2()
{
}

And somewhere in the main code I can have

if(Fun1() && Fun2()) //option-1
{
}

or

if(Fun1() & Fun2()) //option-2 
{
}

It seems with VS2012, with option-1 it is not ensured that both functions are always executed while that happens on option-2 . Specifically if one of the function returns false then other function is not executed with option-1 . However the overall code requires both of them evaluated for proper behavior, which I am able to achieve with option-2 . I would like to know if this behavior of option-2 can change from compiler to compiler (also with optimization levels) or ensured by the standard?

Answer 1

Standard explicitly says that for built-in types like bool operators && and || are short-circuited - ie, the first argument is evaluated first, and than second argument is evaluated only if first argument doesn't give a definitive answer to the statement - ie it is false for || , or true for && .

Bit-wise & is following normal function call rules, so both arguments are evaluated, however, in the unspecified order.

Answer 2

Bitwise- & will always evaluate both operands indeed. The compiler cannot optimize it away due to the as-if rule. But it is a code smell to program like that. Think about people who will maintain your code. Why is there one & instead of two? Is it a typo? etc.

I would at least pull the evaluation out of the if-statement.

  bool fun12 = Fun1() & Fun2();
  if (fun12) {
    . . .

In addition, you can't extend this approach to non- bool functions. You'll have to compare against 0 first.

And finally, && evaluates the first operand and then (optionally) the second. The order of evaluation in & is unspecified (ie random).

Answer 3

&& has short circuit behavior, in other words if the first operand is false, the second is not evaluated. & doesn't have this behavior, so the second always is evaluated for sure. However, if you are handling booleans, always use && not &, because & is used for bitwise operations. For your problem, use this code:

bool a = Fun1();
if(Fun2() && a){
    //Fun2 must be the left operand
}

Answer 4

If you want to run both the function the you can go with option-2 but It's not necessary to call both function you can go with option-1.

Behavior The behavior of option-1 and option-2 is not compiler dependent.

Performance The performance of option-1 is better than option-2

Answer 5

This is not a matter of optimization but a matter of semantics.

&& follows the short-circuit evaluation rule and mustn't perform the second call when the first returns false.

& follows ordinary evaluation and must perform both calls (unless it can prove that there is no side effect).

---

Anyway, one could think of a situation where for an && expression a compiler would enforce the evaluation of the two arguments in all cases (in the absence of a side effect), to exploit parallelism.