Question: I have written a program that lists errors in a set of stuff, and returns a boolean value at the end (returning true means that no error has been found).

Here is a summary of my code :

```
bool checkStuff1() {/*...*/}
bool checkStuff2() {/*...*/}
// ...
bool checkStuffN() {/*...*/}

bool checkAllStuff()
{
    bool result = true;
    result &= checkStuff1();
    result &= checkStuff2();
    // ...
    result &= checkStuffN();
    return result;
}

```

I have confidence the value of `result` will be the right one at the end. However, I would like to be sure that all the functions `checkStuffX()` are called (because they print error messages when failing, and I would like all the error messages to be printed).

I know that if I wrote this way, it would skip all `checkStuffX()` after the first one failing :

```
result = result && checkStuffX(); // Will not call checkStuffX() if result is already false

```

I also know that if I wrote this way, it will call all `checkStuffX()` functions :

```
result = checkStuffX() && result; // Will always call checkStuffX() even if result is false

```

But I was wondering if the behaviour of the code I am using, with bitwise comparison, was determined and guaranteed by the standard ?

Or is there a risk of undefined behaviour, depending on the compiler used and its optimisations ?

Answer: 
This is perfectly fine.

Short-circuit evaluation, to which you're referring to, applies only to the `&&` and `||` operators.
It would work, though conversion int<->bool maybe performance issue, if you have many checks. Oh, you may take advantage of function pointers and for loop, if all functions have same type.

```
bool  (*checks[])( void )= {checkStuff1, checkStuff2 ...  checkStuffN};

bool result = true;
for (int i = 0; i < sizeof(checks)/sizeof(checks[0]); result = checks[i++]() && result );

```

Code would look simpler if you can use ranged for() - like `for(auto i : checks)`. Advantage of that if you have that procedure declared somewhere else in code, need to remove or add a step, you just modify declaration of the array (or your program can change it, effectively changing the workflow!). Downside - you can't use it with checks that have different prototypes.