C++ short-circuiting of booleans

Question

I'm new to c++ and am curious how the compiler handles lazy evaluation of booleans. For example,

if(A == 1 || B == 2){...}

If A does equal 1, is the B==2 part ever evaluated?

Answer 1

No, the B==2 part is not evaluated. This is called short-circuit evaluation .

Edit: As Robert C. Cartaino rightly points out , if the logical operator is overloaded, short-circuit evaluation does not take place (that having been said, why someone would overload a logical operator is beyond me).

Answer 2

Unless the || operator is overloaded , the second expression will not be evaluated. This is called "short-circuit evaluation."

In the case of logical AND (&&) and logical OR (||), the second expression will not be evaluated if the first expression is sufficient to determine the value of the entire expression.

In the case you described above:

if(A == 1 || B == 2) {...}

...the second expression will not be evaluated because

TRUE || ANYTHING TRUE || ANYTHING , always evaluates to TRUE .

Likewise,

FALSE && ANYTHING , always evaluates to FALSE , so that condition will also cause a short-circuit evaluation .

A couple of quick notes

• Short circuit evaluation will not apply to overloaded && and || operators.
• In C++, you are guaranteed that the first expression will be evaluated first. Some languages do not guarantee the order of evaluation and VB doesn't do short-circuit evaluation at all. That's important to know if you are porting code.

Answer 3

The B==2 part is not evaluated.

Be careful! Don't put something like ++B==2 over there!

Answer 4

C ++对布尔表达式求值应用了短路 ，因此，永远不会求值B == 2 ，并且编译器甚至可能完全忽略它。

Answer 5

The compiler handles this by generating intermediate jumps. For the following code:

if(A == 1 || B == 2){...}

compiled to pseudo-assembler, might be:

    load variable A
    compare to constant 1
    if equal, jump to L1
    load variable B
    compare to constant 2
    if not equal, jump to L2
L1:
    ... (complete body of if statement)
L2:
    (code after if block goes here)

Answer 6

This is short-circuit evaluation , as James says. Lazy evaluation is something entirely different.

Answer 7

No it's not.

Same with && , if one is wrong, it doesn't bother evaluating the other one.

Answer 8

B == 2 is never evaluated.

See Short-Circuit Evaluation for more information.