Flowcharts — Loops, goto, break, continue

FC1

🔁 for Loop — Init, Condition, Body, Update

Print 1 to 5 — four flowchart zones: initialise → test → body → update → loop back

for loop

A for loop has four parts that map directly to flowchart zones: Init (rectangle — runs once), Condition (diamond — tested before every iteration), Body (rectangle — runs if condition is true), Update (rectangle — runs after body, then loops back to condition). The back arrow from Update to Condition is the visual signature of a loop — it shows the repeated cycle. When the condition becomes false, the No arrow exits the loop.

Flowchart for(i=1; i<=5; i++)

for_loop.c

#include <stdio.h>
int main() {
    /* ① Init */
    for (int i = 1;
         i <= 5;   /* ② Condition */
         i++) {      /* ④ Update   */
        printf("%d\n", i); /* ③ Body */
    }
    return 0;
}

output

Four zones map exactly to the four parts of a for statement. The flowchart loop-back arrow from Update → Condition is the visual proof that something repeats.

fc2 — while loop

FC2

🔄 while Loop — Condition at the Top, Body Below

Sum of digits of a number — condition tested BEFORE body — may never run

while loop

A while loop tests its condition before entering the body — if the condition is false on the very first check, the body never executes. The flowchart shows this: the decision diamond comes immediately after the start/init, before any process box. The loop-back arrow goes from the bottom of the body directly back up to the diamond — skipping the init (which stays outside the loop). Example: extract digits of a number by repeatedly dividing by 10 until the number becomes 0.

Flowchart while(n > 0)

while_sum_digits.c

#include <stdio.h>
int main() {
    int n = 5765, sum = 0;

    while (n > 0) {       /* condition first */
        sum += n % 10;    /* last digit      */
        n   /= 10;        /* remove digit    */
    }

    printf("Digit sum = %d\n", sum);
    return 0;
}

output

Digit sum = 23

Key difference from do-while: if n = 0 at the start, the body never runs and sum stays 0. The condition diamond blocks entry to the body the moment it's false — even on the first check.

fc3 — do-while loop

FC3

🔁 do-while Loop — Body First, Condition at the Bottom

Menu input validator — body ALWAYS runs at least once — condition tested AFTER

do-while

The do-while loop puts the condition diamond below the body. The body always executes at least once — guaranteed. The flowchart shows: Start → Body → Condition Diamond. If the condition is true, the arrow loops back up to the body (opposite direction from while). If false, it exits. Perfect for menu-driven programs where you must show the menu at least once before checking the choice.

Flowchart do { } while(choice < 1)

do_while_menu.c

#include <stdio.h>
int main() {
    int choice;

    do {                         /* body runs first */
        printf("1.Add 2.Del 3.Exit\n");
        printf("Enter choice: ");
        scanf("%d", &choice);
    } while (choice < 1      /* condition after */
          || choice > 3);

    printf("Valid choice: %d\n", choice);
    return 0;
}

output (invalid then valid)

1.Add 2.Del 3.Exit
Enter choice: 0
1.Add 2.Del 3.Exit
Enter choice: 2
Valid choice: 2

do-while vs while: In the flowchart, the loop-back arrow in do-while points upward to the body. In while, the loop-back arrow points upward to the condition diamond. This single difference is the entire distinction between the two loops.

fc4 — break

FC4

⛔ break — Escape the Loop Immediately

Linear search — break exits the loop the moment the target is found

break

break adds a second exit path to the loop — the early exit. In the flowchart, there are now two arrows leaving the body: the normal loop-back arrow, and a new break arrow that jumps out of the loop entirely, bypassing the condition check. A second decision diamond inside the body represents the if that triggers the break. The moment it fires, execution jumps past the loop to the next statement.

Flowchart break on found

break_search.c

#include <stdio.h>
int main() {
    int arr[] = {10,20,30,40,50};
    int n=5, target=30, found=-1;

    for(int i=0; i<n; i++) {
        if(arr[i] == target) {
            found = i;
            break;  /* EXIT loop NOW */
        }
    }

    if(found >= 0)
        printf("Found at index %d\n",found);
    else
        printf("Not found\n");
    return 0;
}

output

Found at index 2

break only exits ONE loop. In nested loops, break only exits the innermost loop it is inside. The outer loop continues. Use a flag variable or goto if you need to exit multiple loops at once.

fc5 — continue

FC5

⏭️ continue — Skip This Iteration, Loop Again

Print odd numbers only — continue skips even numbers, jumps back to update

continue

continue does not exit the loop — it skips the rest of the current iteration and jumps directly to the update step (for a for loop) or back to the condition (for a while loop). In the flowchart, the continue arrow bypasses the remaining process boxes in the body and connects directly to the update/condition — it is a short-circuit back to the top, not an exit. The loop keeps running; you just skipped this one iteration.

Flowchart continue skips even

continue_odd.c

#include <stdio.h>
int main() {
    printf("Odd numbers 1-10:\n");

    for(int i=1; i<=10; i++) {
        if(i % 2 == 0)
            continue; /* skip even — jump to i++ */

        printf("%d\n", i); /* only reached for odd i */
    }
    return 0;
}

output

Odd numbers 1-10:
1
3
5
7
9

continue in for vs while: In a for loop, continue jumps to the update expression (i++) first, then to the condition. In a while loop, continue jumps directly to the condition. If you put the update inside a while body after a continue, it gets skipped — this causes an infinite loop.

fc6 — nested loops with break + continue

FC6

🔗 Nested Loops — Connector Symbols + break in Inner Loop

Multiplication table — inner loop uses connector circles to keep flowchart readable

Nested + Connector

When loops are nested, flowcharts become complex. Connector circles (labeled A, B, C…) allow the chart to jump between sections without crossing arrows everywhere — you draw circle A at the exit and circle A again at the entry point, and the reader knows they connect. The inner loop for a multiplication table also demonstrates break inside a nested loop — the break only exits the inner loop, and the outer loop continues.

Flowchart — nested for loops with connector symbols

nested_loops.c

#include <stdio.h>
int main() {
    for(int i=1; i<=3; i++) {    /* outer loop — connector A enters inner */
        for(int j=1; j<=5; j++) { /* inner loop */
            printf("%d×%d=%-3d  ", i, j, i*j);
        }                              /* connector B returns to outer */
        printf("\n");
    }
    return 0;
}

output

1×1=1   1×2=2   1×3=3   1×4=4   1×5=5
2×1=2   2×2=4   2×3=6   2×4=8   2×5=10
3×1=3   3×2=6   3×3=9   3×4=12  3×5=15

Connector circles (A, B) are the flowchart equivalent of goto labels — they name a point in the flow so you can connect it from elsewhere without drawing a long crossing arrow. Use them whenever an arrow would cross another or the flowchart becomes too wide.

fc7 — goto

FC7

🏷️ goto — Jump to a Label Anywhere in the Function

Exit nested loops instantly — goto jumps directly to a labelled point — use with care

goto

goto causes an unconditional jump to a labelled statement anywhere in the same function. In the flowchart, a goto is represented as an arrow that crosses over normal flow and lands at a labelled connector or process box. The most legitimate use of goto in C is breaking out of multiple nested loops — where a single break only exits the innermost loop. With goto, you jump directly to code after all the loops.

Flowchart — goto exits nested loops in one jump

goto_nested_exit.c

#include <stdio.h>
int main() {
    int grid[3][3] = {{1,2,3},{4,-1,6},{7,8,9}};

    for(int i=0; i<3; i++) {
        for(int j=0; j<3; j++) {
            printf("Check [%d][%d]=%d\n",i,j,grid[i][j]);
            if(grid[i][j] < 0)
                goto error_exit;   /* jump over BOTH loops */
        }
    }
    printf("All values OK.\n");
    return 0;

error_exit:                          /* label — goto lands here */
    printf("Error: negative value found!\n");
    return 1;
}

output

Check [0][0]=1
Check [0][1]=2
Check [0][2]=3
Check [1][0]=4
Check [1][1]=-1
Error: negative value found!

Use goto sparingly. The only widely accepted use of goto in C is exiting nested loops or centralised error/cleanup handling (common in Linux kernel code). Never use it to jump into a loop, over initialisations, or create spaghetti flow. In modern C, prefer a flag variable or restructuring functions over goto in most cases.

Keyword	What it does	Flowchart arrow direction	Resumes at
break	Exits the current loop or switch immediately	Arrow exits loop box downward	First statement after the loop
continue	Skips rest of body, starts next iteration	Arrow skips to update/condition	Update step (for) or condition (while)
goto label	Jumps unconditionally to labelled statement	Long arrow crosses loop boundaries	The named label anywhere in function

checklist

Flowchart symbols: Oval = Start/End. Rectangle = Process. Diamond = Decision (Yes/No). Parallelogram = Input/Output. Circle = Connector. Arrow = flow direction.
FC1 — for loop: Four zones — Init (once), Condition (diamond before body), Body, Update. Loop-back arrow from Update → Condition. NO arrow exits loop.
FC2 — while loop: Condition diamond comes BEFORE body. If false on first check, body never runs. Loop-back arrow goes from body bottom directly up to condition diamond.
FC3 — do-while: Body comes BEFORE condition diamond. Body always runs at least once. YES arrow from condition loops BACK UP to body. NO arrow exits.
FC4 — break: Second inner decision diamond inside body. YES → break arrow exits loop entirely downward. Resumes at first statement AFTER the loop. Only exits ONE level.
FC5 — continue: Inner decision. YES → continue arrow bypasses rest of body and goes directly to Update (for) or Condition (while). Loop does NOT exit — next iteration starts.
FC6 — nested + connector: Connector circles (A, B) label entry/exit points so arrows don't cross. A connects outer-YES to inner loop entry. B connects inner-NO back to outer update.
FC7 — goto: Long arrow crosses loop boundaries and lands at labelled statement. Only accepted use: exit nested loops or centralised error handling. Never jump INTO loops.

Flowcharts in C —Loops, goto, break & continue

Flowcharts in C —
Loops, goto, break & continue