What are Nested Loops?

A nested loop in C is simply a loop inside another loop. This means that for every single iteration of the outer loop, the inner loop completes all of its iterations. You can nest any type of loop (for, while, do-while) inside another type of loop, or even the same type.

Think of it like an analog clock: the minute hand (inner loop) completes a full 60-minute cycle for every single increment of the hour hand (outer loop). If the hour hand moves 12 times, the minute hand moves 12 * 60 = 720 times.

Nested loops are particularly powerful when you need to work with two-dimensional structures like matrices, tables, or when you want to repeat a sequence of operations multiple times for each primary iteration.

Syntax of Nested Loops

The general syntax for a nested for loop (the most common type for nesting) looks like this:

for (initialization_outer; condition_outer; increment_outer) {
    // Outer loop body
    for (initialization_inner; condition_inner; increment_inner) {
        // Inner loop body
        // This code executes for each iteration of the inner loop
    }
    // Code here executes after the inner loop completes all its iterations,
    // but before the next iteration of the outer loop starts.
}
        

Similar structures apply to while and do-while loops:

// Nested while loops
while (condition_outer) {
    // Outer loop body
    while (condition_inner) {
        // Inner loop body
    }
}

// Nested do-while loops
do {
    // Outer loop body
    do {
        // Inner loop body
    } while (condition_inner);
} while (condition_outer);
        

How Nested Loops Work (Execution Flow)

Understanding the execution flow is key to mastering nested loops:

1. The outer loop initializes.
2. The outer loop's condition is checked. If true, execution enters the outer loop's body.
3. The inner loop initializes.
4. The inner loop's condition is checked. If true, execution enters the inner loop's body.
5. The inner loop's body code executes.
6. The inner loop's increment/decrement statement is executed.
7. Steps 4-6 repeat until the inner loop's condition becomes false.
8. Once the inner loop completes, execution continues with any statements immediately after the inner loop within the outer loop's body.
9. The outer loop's increment/decrement statement is executed.
10. Steps 2-9 repeat until the outer loop's condition becomes false.
11. Once the outer loop completes, the entire nested loop structure finishes execution.

Crucial Point: For every single iteration of the outer loop, the inner loop runs to completion from start to finish.

Practical Examples of Nested Loops

Example 1: Printing a Rectangle/Square Pattern

A classic use case for nested loops is printing geometric patterns using characters.

#include <stdio.h>

int main() {
    int rows = 4;
    int cols = 6;

    printf("Printing a %d x %d rectangle of asterisks:\n", rows, cols);

    for (int i = 0; i < rows; i++) { // Outer loop for rows
        for (int j = 0; j < cols; j++) { // Inner loop for columns
            printf("* "); // Print an asterisk and a space
        }
        printf("\n"); // Move to the next line after each row is complete
    }

    return 0;
}
        

Output:

Printing a 4 x 6 rectangle of asterisks:
* * * * * * 
* * * * * * 
* * * * * * 
* * * * * * 
        

In this example, the outer loop iterates 4 times (for 4 rows). For each iteration of the outer loop, the inner loop iterates 6 times, printing an asterisk. The printf("\n"); ensures that after 6 asterisks are printed, the cursor moves to the next line.

Example 2: Printing a Right-Angled Triangle Pattern

We can modify the inner loop's condition to create different patterns.

#include <stdio.h>

int main() {
    int height = 5;

    printf("Printing a right-angled triangle of height %d:\n", height);

    for (int i = 1; i <= height; i++) { // Outer loop for rows (1 to height)
        for (int j = 1; j <= i; j++) { // Inner loop prints 'i' stars for row 'i'
            printf("* ");
        }
        printf("\n"); // Newline after each row
    }

    return 0;
}
        

Output:

Printing a right-angled triangle of height 5:
* 
* * 
* * * 
* * * * 
* * * * * 
        

Here, the inner loop's condition j <= i makes the number of asterisks printed in each row dependent on the current row number (i). This dynamically changes the number of times the inner loop runs for each outer loop iteration.

Example 3: Generating a Multiplication Table (up to 10)

Nested loops are perfect for tasks like generating tables.

#include <stdio.h>

int main() {
    printf("Multiplication Table (1-10):\n");

    for (int i = 1; i <= 10; i++) { // Outer loop for multiplicands (1 to 10)
        printf("--- Table of %2d ---\n", i);
        for (int j = 1; j <= 10; j++) { // Inner loop for multipliers (1 to 10)
            printf("%2d x %2d = %3d\n", i, j, i * j);
        }
        printf("\n"); // Separate tables with an empty line
    }

    return 0;
}
        

Partial Output:

Multiplication Table (1-10):
--- Table of  1 ---
 1 x  1 =   1
 1 x  2 =   2
 ...
 1 x 10 =  10

--- Table of  2 ---
 2 x  1 =   2
 2 x  2 =   4
 ...
 2 x 10 =  20
...
        

This example clearly demonstrates how the inner loop (multipliers) completes all its iterations for each step of the outer loop (multiplicands), producing a comprehensive multiplication table.

Key Considerations and Best Practices

• Performance: Nested loops can significantly impact performance, especially with deep nesting or large iteration counts. If an outer loop runs N times and an inner loop runs M times, the inner loop's body executes N * M times. Be mindful of this when dealing with large datasets.
• Readability: While powerful, overly complex or deeply nested loops (more than 2-3 levels) can make code hard to read, debug, and maintain. Consider refactoring complex logic into separate functions.
• Initialization: Ensure that any variables used by the inner loop that need to be reset for each outer loop iteration are re-initialized inside the outer loop, but before the inner loop starts.
• Break and Continue: Both break and continue statements only affect the loop they are directly inside. To break out of multiple nested loops, you might need a flag variable or a goto statement (though goto is generally discouraged).