Answer.

Nested loops are one of the main tools of structured programming in C, used to organize the processing of multidimensional data structures (e.g., arrays or matrices).

History of the issue
Nested loops came to C from the ideas of structured programming and are the basis for implementing most algorithms with repetitive operations, including sorting, matrix and table traversal, and dynamic programming tasks.

Problem
The main difficulty lies in the rapidly increasing execution time as the number of nested levels increases (e.g., O(n^2) or O(n^3)), loss of control over loop variables or erroneous use of counters, which leads to infinite loops, incorrect results, or memory overrun.

Solution
It is crucial to clearly plan the nesting, properly name the counter variables, and track their ranges, as well as minimize the number of nesting levels for readability and performance. A good practice is to move nested logic to separate functions.

Code example:

// Printing elements of a two-dimensional array
int arr[3][3] = {
    {1,2,3},
    {4,5,6},
    {7,8,9}
};
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        printf("%d ", arr[i][j]);
    }
    printf("
");
}

Key features:

Each nested loop should have its own counter variables.
Too much nesting decreases readability and performance.
Always check the boundaries of arrays inside nested loops.

Tricky questions.

Can counter variables with the same name be used inside two nested loops?

This is possible only if the scopes of the counters do not overlap (for example, counters are declared inside the body of the innermost loop). Usually, this situation leads to errors and confusion, especially in large programs.

Code example:

for (int i = 0; i < n; i++) {
    for (int i = 0; i < m; i++) { // Error: re-declaring i
        // ...
    }
}

Is it always acceptable to interrupt nested loops with the break statement?

The break statement exits only from the closest loop in which it is located. To exit from all nested loops, you need to use flags or goto. Many developers mistakenly believe that break terminates all outer loops.

Why is it recommended to avoid more than three levels of nested loops?

Each additional level complicates the program's logic, exponentially increases execution time, and makes the code unreadable. It's better to move the nested loop to a separate function or rethink the algorithm.

Typical mistakes and anti-patterns

Using the same counter variable name at different loop levels
Incorrect boundary for the beginning or end of a counter
Excessive nesting of loops (4+ levels)
Forgotten increment/decrement of the counter

Real-life example

Negative case

The team quickly wrote a handler for a three-dimensional matrix using four nested loops with variables i, j, k, l. None of the counter variables had meaningful names, and one of the counters was incremented inside another.

Pros:

Quickly implemented
The problem was implemented in a single file

Cons:

Developers got confused with the counters, leading to index errors
The code was difficult to maintain and optimize

Positive case

The developer moved the processing of one level of nesting into a helper function with good documentation and appropriate counter names. The overall level of nesting was reduced to two.