Continue statement - Deep Dive

Overview - Continue statement

What is it?

The continue statement in C is used inside loops to skip the rest of the current loop iteration and move directly to the next iteration. It works with for, while, and do-while loops. When the program encounters continue, it jumps to the loop's next cycle without executing the remaining code in the current cycle. This helps control the flow inside loops more precisely.

Why it matters

Without the continue statement, programmers would have to write more complex and nested code to skip certain steps in loops. This can make code harder to read and maintain. Continue simplifies skipping unwanted steps, making loops cleaner and easier to understand. It helps avoid bugs caused by complicated conditional logic inside loops.

Where it fits

Before learning continue, you should understand basic loops like for, while, and do-while in C. After mastering continue, you can learn about break statements, nested loops, and more advanced loop control techniques.

Mental Model

Core Idea

Continue tells the loop to skip the rest of this round and start the next one immediately.

Think of it like...

Imagine you are sorting mail and decide to skip any letters addressed to a certain person without opening them. When you see such a letter, you just put it aside and move on to the next one without doing anything else with it.

Loop start
  │
  ▼
Check condition → If false, exit loop
  │
  ▼
Execute loop body
  │    ├─ If 'continue' encountered → jump to loop update step
  │    └─ Else continue executing
  ▼
Loop update (increment or condition check)
  │
  └─ Repeat loop

Build-Up - 7 Steps

1

Foundation

Basic loop structure in C

Concept: Understanding how loops work is essential before using continue.

In C, loops repeat code while a condition is true. For example, a for loop runs a set number of times: for (int i = 0; i < 5; i++) { printf("%d\n", i); } This prints numbers 0 to 4, one per line.

Result

Output: 0 1 2 3 4

Knowing how loops repeat code helps you see where continue can change the flow.

2

Foundation

What does continue do in loops?

Concept: Continue skips the rest of the current loop cycle and moves to the next iteration.

Inside a loop, when continue runs, the program stops the current cycle early and jumps to the next one. For example: for (int i = 0; i < 5; i++) { if (i == 2) continue; printf("%d\n", i); } Here, when i is 2, the printf is skipped.

Result

Output: 0 1 3 4

Continue lets you skip specific steps inside loops without extra nested conditions.

3

Intermediate

Using continue in while loops

Concept: Continue works similarly in while loops, skipping to the next condition check.

Example with while loop: int i = 0; while (i < 5) { i++; if (i == 3) continue; printf("%d\n", i); } When i is 3, printf is skipped, but i still increments.

Result

Output: 1 2 4 5

Continue affects the flow after the current iteration but before the next condition check.

4

Intermediate

Continue with do-while loops

Concept: In do-while loops, continue skips to the condition check after the loop body.

Example: int i = 0; do { i++; if (i == 4) continue; printf("%d\n", i); } while (i < 5); When i is 4, printf is skipped.

Result

Output: 1 2 3 5

Continue always jumps to the loop's next iteration check, even in do-while loops.

5

Intermediate

Common patterns using continue

🤔Before reading on: Do you think continue can replace all if-else conditions inside loops? Commit to yes or no.

Concept: Continue is often used to simplify loops by skipping unwanted cases early.

Instead of nesting code inside if-else, you can use continue to skip unwanted cases: for (int i = 0; i < 10; i++) { if (i % 2 == 0) continue; // skip even numbers printf("%d\n", i); // print only odd numbers } This prints odd numbers from 1 to 9.

Result

Output: 1 3 5 7 9

Using continue reduces nesting and makes loops easier to read by handling special cases upfront.

6

Advanced

Continue in nested loops

🤔Before reading on: Does continue affect all loops when nested, or only the innermost loop? Commit to your answer.

Concept: Continue only affects the loop it is directly inside, not outer loops.

Example: for (int i = 1; i <= 3; i++) { for (int j = 1; j <= 3; j++) { if (j == 2) continue; // skips only inner loop iteration printf("i=%d, j=%d\n", i, j); } } Here, continue skips j=2 but outer loop i continues normally.

Result

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

Knowing continue only affects its own loop prevents confusion in nested loops and bugs.

7

Expert

Subtle effects and pitfalls of continue

🤔Before reading on: Can continue cause infinite loops if used carelessly? Commit to yes or no.

Concept: Continue can cause unexpected behavior if loop variables are not updated properly before continue.

Example of a bug: int i = 0; while (i < 5) { if (i == 2) continue; // i not incremented here printf("%d\n", i); i++; } This causes an infinite loop because i stays 2 forever. Correct version: int i = 0; while (i < 5) { if (i == 2) { i++; continue; } printf("%d\n", i); i++; }

Result

Incorrect: infinite loop Correct: Output 0 1 3 4

Understanding how continue skips code helps avoid infinite loops by ensuring loop variables update correctly.

Under the Hood

When the C program runs a loop, it executes the loop body line by line. When it encounters a continue statement, the program immediately stops executing the rest of the current loop body. Then it jumps to the loop's update step (like incrementing the counter in for loops) or directly to the condition check in while and do-while loops. This jump skips any code after continue in that iteration.

Why designed this way?

Continue was designed to simplify loop control by allowing programmers to skip unnecessary steps without complex nested conditions. It keeps loops readable and reduces errors. Alternatives like deeply nested if-else blocks were harder to read and maintain, so continue provides a clean, explicit way to skip to the next iteration.

┌─────────────┐
│ Loop start  │
└─────┬───────┘
      │
      ▼
┌─────────────┐
│ Condition?  │
└─────┬───────┘
      │Yes
      ▼
┌─────────────┐
│ Loop body   │
│  ┌───────┐  │
│  │continue├─────┐
│  └───────┘  │   │
└─────┬───────┘   │
      │           │
      ▼           │
┌─────────────┐   │
│ Loop update │◄──┘
└─────┬───────┘
      │
      ▼
   Repeat

Myth Busters - 4 Common Misconceptions

Quick: Does continue skip the entire loop or just the current iteration? Commit to your answer.

Common Belief: Continue skips the entire loop and exits it immediately.

Reality: Continue only skips the rest of the current iteration and moves to the next iteration; it does not exit the loop.

Why it matters: Confusing continue with break can cause logic errors where loops run longer or shorter than intended.

Quick: Does continue affect outer loops when used inside nested loops? Commit to yes or no.

Common Belief: Continue affects all loops when nested, skipping multiple levels.

Reality: Continue only affects the innermost loop where it is placed, not outer loops.

Why it matters: Misunderstanding this can cause bugs in nested loops where outer loops behave unexpectedly.

Quick: Can continue cause infinite loops if loop variables are not updated? Commit to yes or no.

Common Belief: Continue cannot cause infinite loops because it just skips code.

Reality: If loop variables are not updated before continue, the loop condition may never change, causing infinite loops.

Why it matters: This misconception leads to hard-to-find bugs and programs that freeze or crash.

Quick: Is continue always better than if-else for skipping code? Commit to yes or no.

Common Belief: Continue is always the best way to skip code inside loops.

Reality: Sometimes if-else is clearer or necessary, especially when multiple conditions affect flow or when skipping is complex.

Why it matters: Overusing continue can make code harder to read or maintain in complex loops.

Expert Zone

1

Continue does not execute loop update code in while loops if placed before the update, which can cause subtle bugs.

2

In for loops, continue jumps to the increment step, so placing continue before increment changes behavior compared to while loops.

3

Using continue in deeply nested loops can reduce readability and make debugging harder, so use it judiciously.

When NOT to use

Avoid continue when loop logic is complex or when skipping code depends on multiple conditions that are clearer with if-else. Also, do not use continue if it risks skipping necessary updates to loop variables, which can cause infinite loops. Instead, restructure the loop or use break statements carefully.

Production Patterns

In real-world C code, continue is often used to handle error cases or skip invalid data early in loops, improving readability. For example, skipping processing when input is invalid. It is also used in performance-critical loops to avoid unnecessary computations. However, many teams limit continue usage to keep code straightforward.

Connections

Break statement

Complementary loop control statements

Understanding continue helps clarify how break differs by exiting loops entirely, while continue only skips to the next iteration.

Exception handling

Both control flow but at different levels

Continue controls loop flow locally, while exceptions handle unexpected events globally; knowing both improves error and flow management.

Traffic signals

Control flow in different domains

Just like a yellow light tells drivers to prepare to stop or proceed carefully, continue signals the program to skip some steps but keep moving forward.

Common Pitfalls

#1 Infinite loop due to missing loop variable update before continue

Wrong approach:

int i = 0;
while (i < 5) {
if (i == 2) continue;
printf("%d\n", i);
i++;
}

Correct approach:

int i = 0;
while (i < 5) {
if (i == 2) {
i++;
continue;
}
printf("%d\n", i);
i++;
}

Root cause:

The loop variable i is not incremented before continue, so when i == 2, the loop never progresses, causing an infinite loop.

#2 Assuming continue exits the loop entirely

Wrong approach:

for (int i = 0; i < 3; i++) {
if (i == 1) continue;
else break;
printf("%d\n", i);
}

Correct approach:

for (int i = 0; i < 3; i++) {
if (i == 1) break;
printf("%d\n", i);
}

Root cause:

Confusing continue with break leads to incorrect loop exit logic.

#3 Using continue in nested loops expecting it to skip outer loop

Wrong approach:

for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
if (j == 1) continue;
printf("%d %d\n", i, j);
}
}

Correct approach:

for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
if (j == 1) break; // or handle outer loop logic explicitly
printf("%d %d\n", i, j);
}
}

Root cause:

Misunderstanding that continue only affects the innermost loop causes unexpected behavior in nested loops.

Key Takeaways

The continue statement skips the rest of the current loop iteration and moves to the next one without exiting the loop.

Continue works in for, while, and do-while loops by jumping to the loop's update or condition check step.

It helps simplify loop code by avoiding nested if-else blocks and handling special cases early.

Misusing continue, especially without updating loop variables, can cause infinite loops or logic errors.

In nested loops, continue only affects the innermost loop, so understanding this prevents bugs.