The Continue Statement in C++

Introduction

In programming, there are situations where you may want to skip the remaining code within the current iteration of a loop and proceed to the next iteration. This is especially useful when you want to ignore specific values or conditions without breaking out of the loop entirely. The continue statement in C++ is designed for this exact purpose — to skip the current iteration of a loop and move on to the next one.

In this post, we will explore the continue statement in detail, understand its syntax, and look at various examples to see how it is applied in different scenarios.

What is the Continue Statement?

The continue statement is used inside loops (such as for, while, and do-while) to skip the rest of the current loop iteration and move directly to the next iteration. It does not terminate the loop, nor does it exit out of the loop. Instead, it allows the loop to continue, but the remaining code for the current iteration is bypassed.

When the continue statement is encountered, the program control is transferred to the loop condition, and the loop proceeds to the next iteration.

---

Syntax of the Continue Statement

The syntax of the continue statement is very simple:

continue;

Once the continue statement is executed, the loop immediately proceeds to the next iteration, skipping any code that follows it within the current iteration.

---

How Does the Continue Statement Work?

To understand how the continue statement works, let’s break down its functionality:

1. Condition Check: The loop begins by checking the loop condition (e.g., i < 10).
2. Continue Trigger: If a specific condition inside the loop is met (such as if (i == 5)), the continue statement is executed.
3. Skip the Remaining Code: When continue is triggered, all the statements following it inside the loop body for that iteration are skipped.
4. Next Iteration: The loop then moves to the next iteration, reevaluates the condition, and continues the loop from the top.

---

Example: Skipping an Iteration

Let’s start with a basic example where we skip a specific number during a loop. We will print the numbers from 0 to 9 but skip the number 5.

#include <iostream>
using namespace std;

int main() {
for (int i = 0; i &lt; 10; i++) {
    if (i == 5) {
        continue;  // Skip iteration when i equals 5
    }
    cout &lt;&lt; i &lt;&lt; endl;  // This will print numbers from 0 to 9, except 5
}
return 0;
}

Output:

0
1
2
3
4
6
7
8
9

In this program, when i equals 5, the continue statement is executed, and the cout statement is skipped for that iteration. The loop moves on to the next iteration (i = 6), and the number 5 is not printed.

---

Example: Skipping Even Numbers

Suppose we want to print only odd numbers between 1 and 10. We can achieve this using the continue statement to skip the even numbers.

#include <iostream>
using namespace std;

int main() {
for (int i = 1; i &lt;= 10; i++) {
    if (i % 2 == 0) {
        continue;  // Skip even numbers
    }
    cout &lt;&lt; i &lt;&lt; " ";  // Print only odd numbers
}
return 0;
}

Output:

1 3 5 7 9

Here, the continue statement ensures that when i is an even number, the loop skips the cout statement and moves on to the next iteration.

---

Using Continue in While Loops

The continue statement can also be used in while and do-while loops. Let’s consider an example where we read integers from the user and sum them, but skip negative numbers.

#include <iostream>
using namespace std;

int main() {
int sum = 0, num;
cout &lt;&lt; "Enter numbers (enter 0 to stop):" &lt;&lt; endl;

while (true) {
    cin &gt;&gt; num;
    
    if (num == 0) {
        break;  // Exit the loop when the user enters 0
    }
    
    if (num &lt; 0) {
        continue;  // Skip negative numbers
    }
    
    sum += num;  // Add positive numbers to sum
}

cout &lt;&lt; "Total sum of positive numbers: " &lt;&lt; sum &lt;&lt; endl;
return 0;
}

Example Input/Output:

Enter numbers (enter 0 to stop):
5
-3
8
-1
0
Total sum of positive numbers: 13

In this example, negative numbers are skipped by the continue statement, and the program only sums the positive numbers.

---

Using Continue in Nested Loops

The continue statement can also be used in nested loops. However, when used in nested loops, it only affects the innermost loop that contains the continue statement. If you need to skip an outer loop iteration, you can use a label and goto (although it’s usually discouraged due to readability concerns).

Here’s an example of how the continue statement works in a nested loop:

#include <iostream>
using namespace std;

int main() {
for (int i = 1; i &lt;= 3; i++) {
    for (int j = 1; j &lt;= 3; j++) {
        if (j == 2) {
            continue;  // Skip when j equals 2
        }
        cout &lt;&lt; "i = " &lt;&lt; i &lt;&lt; ", j = " &lt;&lt; j &lt;&lt; endl;
    }
}
return 0;
}

Output:

i = 1, j = 1
i = 1, j = 3
i = 2, j = 1
i = 2, j = 3
i = 3, j = 1
i = 3, j = 3

Here, the continue statement causes the inner loop to skip the second iteration (when j = 2) and jump directly to j = 3.

---

Difference Between Continue and Break

While the continue statement is used to skip the current iteration of a loop, the break statement is used to terminate the loop entirely, regardless of whether the condition has been met or not.

Here is a quick comparison:

• continue: Skips the current iteration and continues with the next iteration.
• break: Exits the loop completely, no matter what the condition is.

Example of break:

for (int i = 0; i < 10; i++) {
if (i == 5) {
    break;  // Exit the loop entirely when i equals 5
}
cout &lt;&lt; i &lt;&lt; endl;
}

Output:

0
1
2
3
4

In this case, when i equals 5, the break statement is executed, and the loop terminates immediately.

---

Best Practices for Using Continue

While the continue statement can be quite useful, it’s essential to use it judiciously. Here are some best practices for using continue effectively:

1. Clear Intent: Use continue when it makes the code more readable and helps express your intent more clearly. Avoid using it excessively in complex loops, as it can confuse readers.
2. Avoid Excessive Nesting: Deeply nested loops with continue can be challenging to follow. In such cases, consider refactoring the logic into smaller functions or using flags to manage loop flow.
3. Conditional Skips: Use continue for specific conditions that genuinely require skipping an iteration (e.g., ignoring invalid data in an input loop).
4. Maintain Loop Logic: Always ensure that the loop condition is updated properly when using continue to prevent infinite loops or unintended behavior.

---

Common Mistakes with Continue

• Unintended Skips: Forgetting to update the loop variable after using continue can result in skipped iterations or infinite loops.
• Overuse: Overusing continue in loops, especially with complex conditions, can make your code harder to understand. It’s essential to balance readability and logic.
• Confusing With Break: Mixing continue and break can make your loop logic harder to follow. Always use them in a clear context.