Jump Statements in C – Big Picture

C has several jump statements that change the normal flow of execution:

• break – exits the nearest enclosing loop or switch.
• continue – skips the remaining body of the loop and goes to the next iteration.
• goto – jumps to a labelled statement in the same function.
• return – exits from a function (we will study more deeply along with functions).

Used correctly, jump statements make your code simpler. Used badly, they can make your code very hard to read and maintain.

The break Statement in C

break is used to exit immediately from:

• the nearest for loop
• the nearest while or do-while loop
• a switch statement

Syntax

break;

Example – Stop Loop When Condition Met

Find the first multiple of 7 between 1 and 100:

#include <stdio.h>

int main() {
    int i;
    for (i = 1; i <= 100; i++) {
        if (i % 7 == 0) {
            printf("First multiple of 7 = %d\\n", i);
            break;  // exit loop immediately
        }
    }
    printf("Loop finished.\\n");
    return 0;
}

Once i becomes 7, we print it and exit the for loop using break. There is no need to check further numbers.

Example – break Inside switch (Recap)

switch (choice) {
    case 1:
        printf("Start\\n");
        break;    // prevent fall-through
    case 2:
        printf("Stop\\n");
        break;
    default:
        printf("Invalid choice\\n");
}

Technician Example – Fault Search

Suppose you are scanning error codes in an array and want to stop when you find the first critical fault.

int faults[] = {1, 0, 2, 3, 0, 4};  // 3 = critical
int n = 6;
int i;
int foundIndex = -1;

for (i = 0; i < n; i++) {
    if (faults[i] == 3) {
        foundIndex = i;
        break;        // exit as soon as critical fault is found
    }
}

Here break makes the loop efficient and easy to understand: “scan until you find critical, then stop”.

The continue Statement in C

continue is used to skip the rest of the current iteration and move directly to the next iteration of the loop.

Syntax

continue;

Example – Print Only Even Numbers

int i;
for (i = 1; i <= 10; i++) {
    if (i % 2 != 0) {
        continue;  // skip odd numbers
    }
    printf("%d\\n", i);
}

Output: 2 4 6 8 10

Example – Skip Invalid Sensor Readings

Imagine reading 10 sensor values, but values less than 0 are invalid and should not be processed.

int i;
float value;

for (i = 1; i <= 10; i++) {
    printf("Enter reading %d: ", i);
    scanf("%f", &value);

    if (value < 0) {
        printf("Invalid reading, skipping...\\n");
        continue;      // go to next reading
    }

    // process valid value
    printf("Processing value %.2f\\n", value);
}

break vs continue – What Is the Difference?

break and continue in Nested Loops

When loops are nested (loop inside another loop), break and continue affect only the innermost loop where they appear.

Example – Break Inner Loop Only

int row, col;

for (row = 1; row <= 3; row++) {
    for (col = 1; col <= 5; col++) {
        if (col == 3) {
            break;   // exits only the inner loop
        }
        printf("(%d,%d) ", row, col);
    }
    printf("\\n");
}

If you need to break out of multiple levels of loops, you usually:

• Use a flag variable to signal that you want to exit, or
• Refactor code into a function and use return, or
• (Rarely) use goto to jump to a label after the loops.

The goto Statement in C

The goto statement provides an unconditional jump from one point in a function to another point labelled with a name.

Syntax

goto label_name;
/* ... some code ... */
label_name:
    // statements here

Both the goto and the label must be inside the same function.

Simple goto Example (Not Recommended Style)

#include <stdio.h>

int main() {
    int x = 0;

start:
    printf("x = %d\\n", x);
    x++;
    if (x < 5) {
        goto start;      // jump back to label
    }

    printf("Finished.\\n");
    return 0;
}

This program prints x from 0 to 4 using goto. But this is exactly what loops are for. A for or while loop would be much clearer. This is an example of when not to use goto.

When goto Might Be Used (Advanced / Rare Cases)

Although avoided in beginner programs, goto still appears sometimes in:

• Low-level C code (embedded systems, OS kernels).
• Error handling with multiple cleanup steps.
• Breaking out of deeply nested loops plus cleanup.

Example – Error Handling with Cleanup

Consider a function that opens multiple resources and needs to release them properly if something fails in the middle. This is a simplified pattern:

int init_system() {
    int status = 0;

    status = init_module1();
    if (status != 0) {
        goto error_module1;
    }

    status = init_module2();
    if (status != 0) {
        goto error_module2;
    }

    status = init_module3();
    if (status != 0) {
        goto error_module3;
    }

    // success
    return 0;

error_module3:
    cleanup_module2();
error_module2:
    cleanup_module1();
error_module1:
    return -1;
}

Here, goto is used to jump to the correct cleanup block depending on where the error happened. This avoids repeating cleanup code many times. Still, this is an advanced style and not required for beginners.

When to Use & When to Avoid break, continue & goto

Practice Tasks (With break, continue & goto)

1. Prime Number Check: Use a loop and break to check whether a number is prime. Stop checking divisors as soon as you find one.
2. Skip Negatives: Read 10 integers in a loop. Use continue to skip negative numbers and only add positive numbers to a sum.
3. Menu with Exit: Create a calculator menu using a do-while loop and switch. Use break to exit switch and a condition to exit the loop.
4. Search in 2D Table: Use nested loops to search a value in a 2D array. Use break and a flag variable to exit both loops when found.
5. Optional Advanced: In a small function that sets up 2 resources (like two files or two devices), practice writing error cleanup code using labels and goto. Then rewrite the same function without goto using if

Jump Statement Safety Checklist

• Is break exiting only the loop/switch you intend?
• Is continue causing any important code to be skipped accidentally?
• Are you using goto only in very limited, controlled scenarios?
• Would a loop or a separate function be clearer than a goto?
• Can you explain your loop flow to another person easily? If not, simplify.

Suggested Featured Image Prompt

Use this prompt in your image generation tool (DALL·E, etc.) for this article:

“Flat modern 16:9 illustration on a clean light background. Three paths come out of a simple C loop diagram: one path labeled ‘break’ exits the loop box completely, another path labeled ‘continue’ loops back to the condition arrow, and a third zig-zag arrow labeled ‘goto’ jumps to a label icon at the bottom of the screen. On a laptop screen, short C code is visible with `break;`, `continue;` and `goto label;` highlighted. A South Indian / Tamil technician character stands beside the diagram with a caution sign near the word ‘goto’. At the top, bold title text: ‘Break, Continue & goto in C’ and smaller subtitle: ‘When to Use and When to Avoid? | Tamil Technicians’. Clean vector style, minimal colors, educational and high quality.”