Skipping Loop Iterations using `continue`

Free, Unlimited Access

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++

<Excerpt>


This lesson is a quick introductory tour of loops within C++. It is not intended for those who are entirely new to programming. Rather, the people who may find it useful include:

- those who have completed our introductory course, but want a quick review
- those who are already familiar with programming in another language, but are new to C++
- those who have used C++ in the past, but would benefit from a refresher

It summarises several lessons from our introductory course. Anyone looking for more thorough explanations or additional context should consider _**Chapter 2**_ of that course.


</Excerpt>


<CoursePromo course="intro" />


## Conditionals


The implementation of conditionals and loops in C++ is going to be very comfortable for those coming from other languages. The syntax is likely to be very similar


We have the normal `if`, `else if`, and `else` statements:


```c++
int Health{100};

if (Health > 50) {

} else if (Health > 25) {

} else {

}
```


We also have access to ternary statements:


```c++
Health > 50 ? DoSomething() : DoSomethingElse();
```


Finally, we have the typical switch statements. C++ switch statements include “fallthrough” behavior, which we can control using `break`:


```c++
int Number{3};
switch (Number) {
 case 1:
 std::cout << "One";
 break;
 case 2:
 std::cout << "Two";
 break;
 case 3:
 std::cout << "Three";
 break;
 default:
 std::cout << "Something else";
}
```


```c++
//<o>
Three
```


## Short Circuit Evaluation


C++ short circuits evaluation of compound boolean expressions. This means once the result of a boolean is known, any further conditionals within that expression are skipped.


As an example of this, the following program does not log anything. The `std::cout` operations are not executed, because they will not change the result of the boolean expression in which they are used:


```c++
#include <iostream>

int main(){
 // The result will be true
 true || std::cout << "Hi";

 // The result will be false
 false && std::cout << "Hi";
}
```


This can situationally be used as a terse alternative to an `if` statement:


```c++
#include <iostream>
bool ShouldLog{true};

int main(){
 ShouldLog && std::cout << "Hi";//<h>
};
```


```c++
//<o>
Hi
```


Or as an alternative to a series of if-else statements:


```c++
#include <iostream>

bool Log1(){
 return false;
};

bool Log2(){
 std::cout << "Hi from Log2";
 return true;
};

bool Log3(){
 std::cout << "Hi from Log3";
 return true;
};

int main(){
 Log1() || Log2() || Log3();//<h>
}
```


```c++
//<o>
Hi from Log2
```


## Loops


We have the usual 3 looping options that may be recognized from other programming languages: `for`, `while`, and `do while`.


### _**For Loop**_


A `for` loop contains three expressions, separated by semicolons:

- An expression to execute at the start of the loop, used to initialize some state if required
- An expression that returns a boolean, indicating whether the loop should continue
- An expression that will run at the end of each iteration of the loop

A typical form of a `for` loop is below, which will log out the numbers from 1 to 10:


```c++
#include <iostream>

int main(){
 for (int i{1}; i <= 10; ++i) {//<h>
 std::cout <
 }//<h>
}
```


```c++
//<o>
1 2 3 4 5 6 7 8 9 10
```


Each expression is optional. Below, we provide only the middle expression, which controls whether the loop should continue. We still need to include two semicolons in the appropriate place, to clarify which expressions we’re providing:


```c++
#include <iostream>

int main(){
 int i{1};
 for (; i <= 10;) {//<h>
 std::cout << i++ << ' ';//<h>
 }//<h>
}
```


```c++
//<o>
1 2 3 4 5 6 7 8 9 10
```


### While Loop


A while loop accepts a single expression, which determines whether the loop should continue:


```c++
#include <iostream>

int main(){
 int i{1};
 while (i <= 10) {//<h>
 std::cout << i++ << ' ';//<h>
 }//<h>
}
```


```c++
//<o>
1 2 3 4 5 6 7 8 9 10
```


### Do While Loop


A do-while loop has a similar syntax to a while loop, except the conditional is moved to after the block:


```c++
#include <iostream>

int main(){
 int i{1};
 do {//<h>
 std::cout << i++ << ' ';//<h>
 } while (i <= 10);//<h>
}
```


```c++
//<o>
1 2 3 4 5 6 7 8 9 10
```


The key difference with a `do while` loop is that it will always run at least once, even if the boolean that controls the loop is initially `false`.


```c++
#include <iostream>

int main(){
 do {//<h>
 std::cout << "I'm running anyway!";//<h>
 } while (false);//<h>
}
```


```c++
//<o>
I'm running anyway!
```


<Aside>


### For-Each Loops and Container Iteration


Those coming from other languages are likely to be familiar with a dedicated way to iterate over the objects in containers like arrays and sets.


C++ includes these techniques too, which we’ll cover in dedicated sections later in this course.


</Aside>


## Skipping Loop Iterations using `continue`


The `continue` keyword skips over the current loop iteration. Below, we use it to omit `3` from our logging:


```c++
#include <iostream>

int main(){
 for (int i{1}; i <= 10; ++i) {
 if (i == 3) continue;//<h>
 std::cout <
1 2 4 5 6 7 8 9 10
```


## Ending Loops using `break`


The `break` keyword ends our loop entirely. Below, we use it to stop looping once an integer becomes larger than `10`:


```c++
#include <iostream>

int main(){
 int i{1};
 while (true) {
 std::cout << i++ << ' ';
 if (i > 10) break;//<h>
 }
}
```


```c++
//<o>
1 2 3 4 5 6 7 8 9 10
```


## Summary


In this lesson, we explored the fundamentals of conditionals and loops in C++. These constructs allow you to control the flow of your program based on specific conditions and repeat blocks of code as needed. Key takeaways:

- C++ provides if, else if, else, and switch statements for conditional execution
- Ternary operators offer a concise way to make simple conditional assignments
- Short-circuit evaluation optimizes compound boolean expressions
- for, while, and do-while loops enable repeated execution of code blocks
- The continue keyword skips the current loop iteration, while break terminates the loop entirely

<FAQ>


```javascript
//<m>
{
 slug: 'using-break-in-nested-loops',
 title: 'Using break in Nested Loops',
 question: 'How can I break out of nested loops using the break keyword?',
}
```


When using nested loops, the `break` keyword only breaks out of the innermost loop in which it is used. If you want to break out of multiple levels of nested loops, you can use a flag variable:


```c++
#include <iostream>

int main() {
 bool breakOut{false};
 for (int i{0}; i < 5; ++i) {
 for (int j{0}; j < 5; ++j) {
 if (i == 2 && j == 3) {
 breakOut = true;
 break;
 }
 std::cout << "(" <
 }
}
```


```text
//<o>
(0, 0)
(0, 1)
(0, 2)
(0, 3)
(0, 4)
(1, 0)
(1, 1)
(1, 2)
(1, 3)
(1, 4)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
```


</FAQ>


<FAQ>


```javascript
//<m>
{
 slug: 'conditional-operator-precedence',
 title: 'Conditional Operator Precedence',
 question: 'What is the precedence of the conditional (ternary) operator compared to other operators?',
}
```


The conditional (ternary) operator `? :` has relatively low precedence compared to most other operators in C++. It has lower precedence than the arithmetic, comparison, and bitwise operators, but higher precedence than the assignment and comma operators.


This means that expressions involving the conditional operator may need to be parenthesized to ensure the desired evaluation order. For example:


```c++
#include <iostream>

int main() {
 int x{5}, y{10};

 // This is evaluated as (1 + false) ? 2 : 3
 // Which becomes true ? 2 : 3
 // Which becomes 2
 int result1 = 1 + false ? 2 : 3; //<e>
 std::cout << "result1: " << result1 << "\n";

 // This is evaluated as 1 + (false ? 2 : 3)
 // Which becomes 1 + 3
 // Which becomes 4
 int result2 = 1 + (false ? 2 : 3); //<h>
 std::cout << "result2: " << result2 << "\n";
}
```


```text
//<o>
result1: 2
result2: 4
```


In the first case, `result1` is incorrectly evaluated as `(1 + 0) ? 2 : 3)` due to operator precedence, resulting in `2`. In the second case, `result2` is correctly evaluated as intended, yielding 4.


To avoid confusion and ensure clarity, it's generally a good practice to use parentheses when combining the conditional operator with other operators in complex expressions. This can include adding superfluous parentheses - even if they don’t change the behaviour of the expression, they can sometimes make the expression easier to understand.


</FAQ>


<FAQ>


```javascript
//<m>
{
 slug: 'do-while-loop-condition',
 title: 'Condition in a do-while Loop',
 question: 'Is it possible to have a condition that always evaluates to false in a do-while loop?',
}
```


Yes, it is possible to have a condition that always evaluates to false in a do-while loop. In such cases, the loop body will execute exactly once, regardless of the condition.


Here's an example:


```c++
#include <iostream>

int main() {
 do {
 std::cout << "This will be printed once.\n";
 } while (false);//<h>

 std::cout << "Loop ended.\n";
}
```


```text
//<o>
This will be printed once.
Loop ended.
```


In this code, the condition `false` is used in the do-while loop. Since the condition is always false, the loop body is executed once, and then the loop terminates.


This behavior can be useful in situations where you want to ensure that a certain block of code is executed at least once, even if the condition is initially false. However, it's important to be cautious when using such constructs, as they can make the code less readable and potentially confusing.


In most cases, if you only need to execute a block of code once, it's clearer to use an if statement or simply write the code without any loop construct.


</FAQ>


<FAQ>


```javascript
//<m>
{
 slug: 'short-circuit-evaluation-order',
 title: 'Short-Circuit Evaluation Order',
 question: 'In what order are the conditions evaluated in short-circuit evaluation?',
}
```


In short-circuit evaluation, the conditions are evaluated from left to right until the overall result of the expression can be determined. The evaluation stops as soon as the result is known, without evaluating the remaining conditions.


For the logical OR operator `||`, if any condition evaluates to true, the entire expression is true, and the remaining conditions are not evaluated. For example:


```c++
#include <iostream>

bool condition1() {
 std::cout << "Evaluating condition1\n";
 return true;
}

bool condition2() {
 std::cout << "Evaluating condition2\n";
 return false;
}

int main() {
 if (condition1() || condition2()) {//<h>
 std::cout << "At least one condition is true.\n";
 }
}

```


```text
//<o>
Evaluating condition1
At least one is true.
```


In this example, `condition1()` is evaluated first and returns true. Since the logical OR only requires one true condition, `condition2()` is not evaluated, and the program proceeds to execute the code block.


For the logical AND operator `&&`, if any condition evaluates to false, the entire expression is false, and the remaining conditions are not evaluated. For example:


```c++
#include <iostream>

bool condition1() {
 std::cout << "Evaluating condition1\n";
 return false;
}

bool condition2() {
 std::cout << "Evaluating condition2\n";
 return true;
}

int main() {
 if (condition1() && condition2()) {//<h>
 std::cout << "Both conditions are true.\n";
 } else {
 std::cout << "At least one is false.\n";
 }
}
```


```text
//<o>
Evaluating condition1
At least one is false.
```


In this case, `condition1()` is evaluated first and returns false. Since the logical AND requires all conditions to be true, `condition2()` is not evaluated, and the program executes the else block.


Short-circuit evaluation allows for more efficient execution by avoiding unnecessary evaluations and can be used to prevent potential errors, such as dividing by zero or accessing null pointers, by placing those checks first in the condition.


</FAQ>


<FAQ>


```javascript
//<m>
{
 slug: 'infinite-loop-detection',
 title: 'Detecting Infinite Loops',
 question: 'How can I detect and prevent infinite loops in my C++ code?',
}
```


Detecting and preventing infinite loops is an important aspect of writing robust and reliable C++ code. Here are a few techniques you can use to identify and avoid infinite loops:


### Analyze loop conditions

- Ensure that the loop condition eventually becomes false. If the condition always remains true, the loop will continue indefinitely.
- Check for proper initialization and updating of loop variables.

### Use a counter or a flag

- Introduce a counter variable that increments with each iteration and set a maximum limit. If the counter exceeds the limit, break the loop and log an error.
- Use a flag variable to indicate a specific condition that should terminate the loop.

```c++
#include <iostream>

int main() {
 int count{0};
 while (true) {
 ++count;
 if (count > 1000) { //<h>
 std::cout << "Potential infinite loop"
 " detected. Breaking...\n";
 break;
 }
 }
}
```


```c++
//<o>
Potential infinite loop detected. Breaking...
```


### Utilize debugging tools

- Use a debugger to step through the code and observe the loop's behavior.
- Set breakpoints and inspect variable values to identify why the loop continues indefinitely.

### Test with different inputs

- Provide various inputs to your program, including edge cases, to ensure the loop behaves as expected.
- Consider writing unit tests that cover different scenarios and verify the loop's termination.

### Review and reason about the code

- Carefully read and understand the purpose and logic of the loop.
- Identify any missing or incorrect loop control statements.
- Verify that the loop progresses towards its intended termination condition.

In this example, the loop variable `i` is not incremented, causing an infinite loop:


```c++
#include <iostream>

int main() {
 int i{0};
 while (i < 10) {
 std::cout <
 }
}
```


```c++
//<o>
0
0
0
...
```


### Set a timeout or a maximum execution time

- In some cases, you can set a timeout or a maximum execution time for your program.
- If the loop exceeds the specified time limit, terminate the program and log an error.

Example using `std::chrono`:


```c++
#include <chrono>
#include <iostream>

int main() {
 using namespace std::chrono;
 auto start = steady_clock::now();
 while (true) {
 auto current = steady_clock::now();
 auto duration = duration_cast<seconds>(
 current - start);
 if (duration.count() > 5) { //<h>
 std::cout
 << "Timeout exceeded. Terminating...\n";
 break;
 }
 }
}
```


```c++
//<o>
Timeout exceeded. Terminating...
```


By applying these techniques and being cautious when writing loop conditions, you can detect and prevent infinite loops in your C++ code, ensuring more stable and predictable program behavior.


</FAQ>


<FAQ>


```javascript
//<m>
{
 slug: 'loop-variable-scope',
 title: 'Scope of Loop Variables',
 question: 'What is the scope of variables declared within the initialization statement of a for loop?',
}
```


In C++, variables declared within the initialization statement of a for loop have a scope limited to the loop body. The variables are only accessible within the loop and are destroyed at the end of each iteration. Example:


```c++
#include <iostream>

int main() {
 for (int i = 0; i < 5; ++i) {
 // i is accessible within the loop body
 std::cout <
}
```


```c++
//<oe>
error: 'i': undeclared identifier
```


In this example, the variable `i` is declared within the initialization statement of the for loop. It is accessible only within the loop body and cannot be used outside the loop.


If you need to access the loop variable after the loop ends, you can declare it before the loop and use it within the loop initialization statement:


```c++
#include <iostream>

int main() {
 int i;
 for (i = 0; i < 5; ++i) {
 // i is accessible within the loop body
 std::cout <
0
1
2
3
4
Final value of i: 5
```


By declaring the variable `i` outside the loop, you can control its scope and access it after the loop if needed.


The scope rules for variables declared in the initialization statement of a for loop apply to all versions of C++, ensuring consistent behavior across different standards.


</FAQ>

Learn the fundamentals of controlling program flow in C++ using if statements, for loops, while loops, continue, and break

Using break in Nested Loops

Conditional Operator Precedence

Condition in a do-while Loop

Short-Circuit Evaluation Order

Detecting Infinite Loops

Scope of Loop Variables

Updated references and added summary and FAQs

Added AI assistant, table of contents and references

Intro to C++

if statement

switch statement

for loop

while loop

do-while loop

Control Structures

Decision Making in C / C++

Loops in C/C++

Statements (C++)

UPDATED FOR C++23 | Learn the fundamentals of controlling program flow in C++ using if statements, for loops, while loops, continue, and break | Clear explanations and simple code examples

Conditional Operator Precedence

What is the precedence of the conditional (ternary) operator compared to other operators?

Conditionals and Loops

How can I break out of nested loops using the break keyword?

Is it possible to have a condition that always evaluates to false in a do-while loop?

In what order are the conditions evaluated in short-circuit evaluation?

How can I detect and prevent infinite loops in my C++ code?

What is the scope of variables declared within the initialization statement of a for loop?

Conditionals and Loops

Professional C++

This course includes:

Professional C++