Will the C/C++ compiler optimize this if statement?

Question

I have code like this, and I find it a bit hard to read:

// code1
if( (expensiveOperation1() && otherOperation() && foo()) 
     || (expensiveOperation2() && bar() && baz()) {
  // do something
}

I just changed it to the following, to make it more readable:

// code2
const bool expr1 = expensiveOperation1() && otherOperation() && foo();
const bool expr2 = expensiveOperation2() && bar() && baz();
if(expr1 || expr2){
   // one of the conditions met
}

But should I now be concerned about efficiency?

I mean, in code1, if the first conjunctive clause is fulfilled then it won't even bother to look at the second one because it's already clear that the statement will be true.

But in my more readable example, both cond1 and cond2 have to be computed. Or will the compiler be smart enough to change my code2 into code1 if expr2 is not used anywhere else?

Answer 1

Maybe, but why not just make your second check incorporate the first?

// code3
bool expr = expensiveOperation1() && otherOperation() && foo();
expr = expr || (expensiveOperation2() && bar() && baz());
if(expr){
   // one of the conditions met
}

Better yet, turn things around so the least expensive check occurs first in each list, taking advantage of the lazy evaluation to skip the expensive operations entirely.

Answer 2

I would say it shouldn't, since they're not logically equivalent if any of the functions have side-effects.

The following would be equivalent however, and it'd have the advantage allowing you to give descriptive names to the test functions, making the code more self-documenting:

// code3
inline bool combinedOp1()
{
    return expensiveOperation1() && otherOperation() && foo();
}

inline bool combinedOp2()
{
    return expensiveOperation2() && bar() && baz();
}

And then call it as follows:

if (combinedOp1() || combinedOp2())
{
    // do something
}

Answer 3

Well, the compiler in general will not reorder &&'s and ||'s on the off chance that the conditions have side effects. a few very smart compilers might be able to statically verify their independence, but this is going to be rare.

If possible, reorder your conditions for the cheap operations to come first, so it can short circuit the expensive ones.

Answer 4

The answer to this question depends on the compiler of course. The definitive way to check is to look at the assembly generated by the compiler for this function. Most (all?) compilers have a way to do this, for instance gcc has the -S option. If for some bizarre reason yours doesn't most debuggers can show you the disassembly for a function, or there are other tools to do this with.

Answer 5

Good answers.

I would only add that I don't like compilers to be so aggressive in optimizing as to re-order my code.

I just want a compiler to do what it's told.

If it's able to outsmart me, it can also outsmart itself.

Answer 6

The top answers here are answering the question with "should not" and "maybe"! That isn't a definitive answer come on!

If you want to know if your compiler is optimizing this tiny bit of code, compile your code with the "show assembly output" flag. On GCC that flag is "-S". Then look at the output assembly and it will show you EXACTLY 100% what is being compiled or not.

Then you can compare your first code snipped to the code snippet from "therefromhere" and rapidly try numerous code changes until you find one that the compiler optimizes the best ( i.e. least cycles ).

It sounds complex and scary to look at the asm output but in reality it only takes about 5 minutes to do. I have done an example here: http://stackoverflow.com/questions/36906/what-is-the-fastest-way-to-swap-values-in-c/615995#615995

Answer 7

The compiler can optimize if it knows that the functions in cond2 (expensiveOperation2(), bar() and baz()) are pure (ie have no side-effects). If they are pure, the simplest way to make sure the compiler knows it is to make them inline functions.

It is possible that the compiler can tell even if you don't, but its very unlikely since expensiveOperation2() probably does quite a lot of work.

FWIW, if those functions are pure, you should probably re-order them so that bar() and baz() run before expensiveOperation2() (and same for the ordering in cond1).