# 7.10 — Break and continue

Break

Although you have already seen the `break statement` in the context of `switch statements` (7.4 -- Switch statement basics), it deserves a fuller treatment since it can be used with other types of loops as well. The break statement causes a while loop, do-while loop, for loop, or switch statement to end, with execution continuing with the next statement after the loop or switch being broken out of.

Breaking a switch

In the context of a `switch statement`, a `break` is typically used at the end of each case to signify the case is finished (which prevents fallthrough into subsequent cases):

See lesson %Failed lesson reference, id XX% for more information about fallthrough, along with some additional examples.

Breaking a loop

In the context of a loop, a break statement can be used to end the loop early. Execution continues with the next statement after the end of the loop.

For example:

This program allows the user to type up to 10 numbers, and displays the sum of all the numbers entered at the end. If the user enters 0, the break causes the loop to terminate early (before 10 numbers have been entered).

Here’s a sample execution of the above program:

```Enter a number to add, or 0 to exit: 5
Enter a number to add, or 0 to exit: 2
Enter a number to add, or 0 to exit: 1
Enter a number to add, or 0 to exit: 0
The sum of all the numbers you entered is: 8
```

Break is also a common way to get out of an intentional infinite loop:

A sample run of the above program:

```Enter 0 to exit or anything else to continue: 5
Enter 0 to exit or anything else to continue: 3
Enter 0 to exit or anything else to continue: 0
We're out!
```

Break vs return

New programmers sometimes have trouble understanding the difference between `break` and `return`. A `break statement` terminates the switch or loop, and execution continues at the first statement beyond the switch or loop. A `return statement` terminates the entire function that the loop is within, and execution continues at point where the function was called.

Here are two runs of this program:

```Enter 'b' to break or 'r' to return: r
Function breakOrReturn returned 1
```
```Enter 'b' to break or 'r' to return: b
We broke out of the loop
Function breakOrReturn returned 0
```

Continue

The continue statement provides a convenient way to end the current iteration of a loop without terminating the entire loop.

Here’s an example of using continue:

This program prints all of the numbers from 0 to 9 that aren’t divisible by 4:

```1
2
3
5
6
7
9
```

`Continue statements` work by causing the current point of execution to jump to the bottom of the current loop.

In the case of a for loop, the end-statement of the for loop still executes after a continue (since this happens after the end of the loop body).

Be careful when using a `continue statement` with while or do-while loops. These loops typically change the value of variables used in the condition inside the loop body. If use of a `continue statement` causes these lines to be skipped, then the loop can become infinite!

Consider the following program:

This program is intended to print every number between 0 and 9 except 5. But it actually prints:

```0 1 2 3 4
```

and then goes into an infinite loop. When `count` is `5`, the `if statement` evaluates to `true`, and the `continue` causes the execution to jump to the bottom of the loop. The `count` variable is never incremented. Consequently, on the next pass, `count` is still `5`, the `if statement` is still `true`, and the program continues to loop forever.

Of course, you already know that if you have an obvious counter variable, you should be using a `for loop`, not a `while` or `do-while` loop.

The debate over use of break and continue

Many textbooks caution readers not to use `break` and `continue` in loops, both because it causes the execution flow to jump around, and because it can make the flow of logic harder to follow. For example, a `break` in the middle of a complicated piece of logic could either be missed, or it may not be obvious under what conditions it should be triggered.

However, used judiciously, `break` and `continue` can help make loops more readable by keeping the number of nested blocks down and reducing the need for complicated looping logic.

For example, consider the following program:

This program uses a boolean variable to control whether the loop continues or not, as well as a nested block that only runs if the user doesn’t exit.

Here’s a version that’s easier to understand, using a `break statement`:

In this version, by using a single `break statement`, we’ve avoided the use of a Boolean variable (and having to understand both what its intended use is, and where its value is changed), an `else statement`, and a nested block.

Minimizing the number of variables used and keeping the number of nested blocks down both improve code comprehensibility more than a `break` or `continue` harms it. For that reason, we believe judicious use of `break` or `continue` is acceptable.

Best practice

Use break and continue when they simplify your loop logic.

 7.11 -- Halts (exiting your program early) Index 7.9 -- For statements

### 40 comments to 7.10 — Break and continue

• In th "continue" section of this chapter, the first code sample is broken.
In line 8, "iii" should be "count"

• Alex

Thanks!

• Sorry...
In my suggestion,

should be:

• A suggestion. In Break vs Return section, you can write the example like this:

Correct me if I am wrong. I found this easier to understand. It may not.

• Alex

I think this does help clarify the intent of each. I've updated the example accordingly.

• Niranjan

Hi Alex,
Really great tutorial. However I am one of those people who is just revisiting c++ to brush up the skills and avoiding the pitfalls. I think what would be great is if you can add a small box (with an icon indicating danger) around text items where you give advice about dangers and common mistakes. That way it is easy for people like me to browse through this faster and for newbs to remember.

Thanks

• Alex

Good idea. I'll look into it.

• cpplx

a lot of comments about the content of this lesson.
mine will be about the use of the term "program" for a snippet
and the usage of post(blah++) instead of pre(++blah) increment.
minor things but they confuse me as a beginner in what is the proper way.
i hope this comments are helpful for future updates and revisions instead of annoying :)

• Alex

Also fixed, I think.

• Todd

Typo.

In the first block of code you reference, all your function names begin with a capital letter (e.g., DoAddition), but these should begin with a lowercase letter by naming conventions (e.g., doAddition)

• Alex

Fixed.

• A suggestion for a useful coding style:

When using break and/or continue in loops, try to have them either right at the start or end, preferably at the start, so they are easy to spot and thus keeping the control flow easy to read.

Another suggestion, wouldn't having a chapter about understanding the flow of the loops be appropriate? I'm mostly thinking of things like is there an invariant (eg. int count tells us which numbers has been printed so far) and are there any termination conditions, so the loop can actually terminate. And also as you touch upon with the continue are there any control flow that can make the termination condition(s) inaccessible.

• GREAT TUTORIAL MASTER ALEX

• DrSuse

Considering this little snippet:
``` int iii=0; while (iii < 10) { if (iii==5) continue; cout << iii << " "; iii++; } ```
Is there any elegant way to make this work as intended as a "while" function?
If you put the increment (iii++) before the if, then "0" never gets printed. The only way I know to get "0" included in the output this way is to initialize iii as -1, which seems like a very sloppy way to do things.
You could replace "continue;" with an "iii++" and get the desired result, , but I would like to see how this could be done, simply and elegantly, using the "continue" statement.

``` int iii=0; while (iii < 10) { if (iii==5) { iii++; continue; } cout << iii << " "; iii++; } ```