Short-circuit Evaluation

When we combine boolean values using the AND (&&) and OR (||) operators, C++ and most other programming languages are smart about how it evaluates them. It performs what's known as short-circuit evaluation.

This means that the second operand in a logical expression is only evaluated if its value is absolutely necessary to determine the final result. We'll walk through some examples in this lesson.

This short-circuiting behavior is not just a performance optimization - we can also use it to control the flow of our code, much like we'd use if and else statements.

For example, imagine we have two tasks that must be performed in sequence, but the second task should only be attempted if the first one succeeds. We could write this using an if statement, which works perfectly fine:

1#include <iostream>
2using namespace std;
3
4bool TaskOne() {
5  cout << "Performing task one...\n";
6  // ...
7  cout << "Something went wrong!\n";
8  return false;
9}
10
11bool TaskTwo() {
12  cout << "Performing task two...\n";
13  // ...
14  cout << "Success!\n";
15  return true;
16}
17
18int main(){
19  bool TaskOneComplete{TaskOne()};
20  if (TaskOneComplete) {
21    TaskTwo();
22  }
23}

1Performing task one...
2Something went wrong!

However, by using the short-circuiting behavior of the && and || operators, we can write sequential dependencies like this in a much simpler way.

In an expression like TaskOne() && TaskTwo(), if TaskOne() evaluates to false, TaskTwo() is never evaluated, meaning TaskTwo is not invoked.

The reason for this is that it doesn't matter what TaskTwo() returns - it is not going to change the value returned by the && operator.

After TaskOne() returns false, the expression is equivalent to false && TaskTwo(). The expression false && anything will return false regardless of the value of anything, so our program won't even check what anything is.

The following program shows this in action:

1#include <iostream>
2using namespace std;
3
TaskOne Function (Unchanged)|Show
4bool TaskOne() {/*...*/}
11
TaskTwo Function (Unchanged)|Show
12bool TaskTwo() {/*...*/}
19
20int main(){
21  bool TasksCompleted{TaskOne() && TaskTwo()};
22  if (!TasksCompleted) {
23    cout << "Failed to complete the tasks";
24  }
25}

Note how TaskTwo() isn't executed if TaskOne() returns false:

1Performing task one...
2Something went wrong!
3Failed to complete the tasks

We can extend this pattern to any number of evaluations. The following expression will continue until one of the tasks returns false:

1bool TasksCompleted{
2  TaskOne() &&
3  TaskTwo() &&
4  TaskThree() &&
5  TaskFour()
6};

1#include <iostream>
2using namespace std;
3
4bool ShouldLog(int x) {
5  return x > 5;
6}
7
8int main(){
9  int Value{3};
10  ShouldLog(Value) && cout << Value;
11}

The same logic applies to the || operator. It doesn't evaluate operands unnecessarily - as soon as knows the result of the overall expression, it returns it.

This means that, in an expression like OptionOne() || OptionTwo(), if OptionOne() returns true, OptionTwo() is never evaluated.

This is because it doesn't matter what OptionTwo() will return - if OptionOne() was true, the overall expression is going to be true. In other words, true || anything is true regardless of the value of anything.

In the following example, we provide two options to complete a task. The program will stop as soon as it finds one that works:

1#include <iostream>
2using namespace std;
3
4bool OptionOne() {
5  cout << "Trying option one...\n";
6  // ...
7  cout << "Success!\n";
8  return true;
9}
10
11bool OptionTwo() {
12  cout << "Trying option two...\n";
13  // ...
14  cout << "Success!\n";
15  return true;
16}
17
18int main(){
19  bool WorkDone{OptionOne() || OptionTwo()};
20  if (WorkDone) {
21    cout << "Work completed successfully";
22  }
23}

Note how OptionTwo() isn't called if OptionOne() returns true:

1Trying option one...
2Success!
3Work completed successfully

In this lesson, we've learned about short-circuit evaluation, a key feature of logical operators that makes our code more efficient and concise.

• && (AND) stops evaluating as soon as it finds a false operand. The expression A && B will not evaluate B if A is false.
• || (OR) stops evaluating as soon as it finds a true operand. The expression A || B will not evaluate B if A is true.
• Benefits: This behavior allows us to write more performant code by avoiding unnecessary function calls, and gives us a concise way of creating sequential conditions in a single expression.