LEARN C++

Skill up with our free tutorials

7.2 — If statements and blocks

 ALEX1  AUGUST 10, 2022

The first category of control flow statements we’ll talk about are the conditional statements. A conditional
statement is a statement that specifies whether some associated statement(s) should be executed or not.

C++ supports two basic kinds of conditionals: if statements (which we introduced in lesson 4.10 -- Introduction to
if statements (https://www.learncpp.com/cpp-tutorial/introduction-to-if-statements/)2, and will talk about further here) and switch
statements (which we’ll cover in a couple of lessons).

Quick if-statement recap

The most basic kind of conditional statement in C++ is the if statement . An if statement takes the form:

if (condition)

true_statement;

or with an optional else statement :

if (condition)

true_statement;

else

false_statement;

If the condition evaluates to true , the true_statement executes. If the condition evaluates to false and the
optional else statement exists, the false_statement executes.

Here is a simple program that uses an if statement with the optional else statement :

1 #include <iostream>

3 int main()

4 {

5 std::cout << "Enter a number: ";

6 int x{};

7 std::cin >> x;

9 if (x > 10)

10 std::cout << x << " is greater than 10\n";

11 else

12 std::cout << x << " is not greater than 10\n";

13

14 return 0;

15 }

This program works just like you’d expect:

 Enter a number: 15

15 is greater than 10

Enter a number: 4

4 is not greater than 10

If or else with multiple conditional statements

New programmers often try something like this:

1 #include <iostream>

3 int main()

4 {

5 std::cout << "Enter your height (in cm): ";

6 int x{};

7 std::cin >> x;

9 if (x > 140)

10 std::cout << "You are tall enough to ride.\n";

11 else

12 std::cout << "You are not tall enough to ride.\n";

13 std::cout << "Too bad!\n"; // focus on this line

14

15 return 0;

16 }

However, consider the following run of the program:

Enter your height (in cm): 180

You are tall enough to ride.

Too bad!

This program doesn’t work as expected because the true_statement and false_statement can only be a single
statement. The indentation is deceiving us here -- the above program executes as if it had been written as follows:

1 #include <iostream>

3 int main()

4 {

5 std::cout << "Enter your height (in cm): ";

6 int x{};

7 std::cin >> x;

9 if (x > 140)

10 std::cout << "You are tall enough to ride.\n";

11 else

12 std::cout << "You are not tall enough to ride.\n";

13

14 std::cout << "Too bad!\n"; // focus on this line

15

16 return 0;

17 }

This makes it clearer that “Too bad!” will always execute.

However, it’s common to want to execute multiple statements based on some condition. To do so, we can use a
compound statement (block):

1 #include <iostream>

3 int main()

4 {

5 std::cout << "Enter your height (in cm): ";

6 int x{};

7 std::cin >> x;

9 if (x > 140)

10 std::cout << "You are tall enough to ride.\n";

11 else

12 { // note addition of block here

13 std::cout << "You are not tall enough to ride.\n";

14 std::cout << "Too bad!\n";

15 }

16

17 return 0;

18 }

Remember that blocks are treated as a single statement, so this now works as expected:

Enter your height (in cm): 180

You are tall enough to ride.

Enter your height (in cm): 130

You are not tall enough to ride.

Too bad!

To block or not to block single statements

There is debate within the programmer community as to whether single statements following an if or else should
be explicitly enclosed in blocks or not.

There are two reasons typically given as rationale for doing so. First, consider the following snippet:

1 if (age >= 21)

2 purchaseBeer();

Now let’s say we’re in a hurry and modify this program to add another ability:

1 if (age >= 21)

2 purchaseBeer();

3 gamble(); // will always execute

Oops, we’ve just allowed minors to gamble. Have fun in jail!

Second, it can make programs more difficult to debug. Let’s say we have the following snippet:

1 if (age >= 21)

2 addBeerToCart();

4 checkout();
Let’s say we suspect something is wrong with the addBeerToCart() function, so we comment it out:

1 if (age >= 21)

2 // addBeerToCart();

4 checkout();

Now we’ve made checkout() conditional, which we certainly didn’t intend.

Neither of these problems occur if you always use blocks after an if or else statement.

The best argument for not using blocks around single statements is that adding blocks makes you able to see less of
your code at one time by spacing it out vertically, which makes your code less readable and can lead to other, more
serious mistakes.

The community seems to be more in favor of always using blocks than not, though this recommendation certainly
isn’t ubiquitous.

Best practice
Consider putting single statements associated with an if or else in blocks (particularly while you are
learning). More experienced C++ developers sometimes disregard this practice in favor of tighter vertical
spacing.

A middle-ground alternative is to put single-lines on the same line as the if or else :

1 if (age >= 21) purchaseBeer();

This avoids both of the above downsides mentioned above at some minor cost to readability.

Implicit blocks
If the programmer does not declare a block in the statement portion of an if statement or else statement , the
compiler will implicitly declare one. Thus:

if (condition)

true_statement;

else

false_statement;

is actually the equivalent of:

if (condition)

true_statement;

else

false_statement;

Most of the time, this doesn’t matter. However, new programmers sometimes try to do something like this:

1 #include <iostream>

3 int main()

4 {

5 if (true)

6 int x{ 5 };

7 else

8 int x{ 6 };

10 std::cout << x << '\n';

11

12 return 0;

13 }

This won’t compile, with the compiler generating an error that identifier x isn’t defined. This is because the above
example is the equivalent of:

1 #include <iostream>

3 int main()

4 {

5 if (true)

6 {

7 int x{ 5 };

8 } // x destroyed here

9 else

10 {

11 int x{ 6 };

12 } // x destroyed here

13

14 std::cout << x << '\n'; // x isn't in scope here

15

16 return 0;

17 }

In this context, it’s clearer that variable x has block scope and is destroyed at the end of the block. By the time we
get to the std::cout line, x doesn’t exist.

We’ll continue our exploration of if statements in the next lesson.

Next lesson
 7.3 Common if statement problems
3

 Back to table of contents

4

Previous lesson
 7.1 Control flow introduction
5