A nested loop has one loop inside of another. These are typically used for working with two dimensions such as printing stars in rows and columns as shown below. When a loop is nested inside another loop, the inner loop runs many times inside the outer loop. In each iteration of the outer loop, the inner loop will be re-started. The inner loop must finish all of its iterations before the outer loop can continue to its next iteration.
Example:
for(int row = 0; row < 3; row++) {
for(int col = 0; col < 5; col++) {
cout << '*';
}
cout << '\n';
}
// This code prints a rectangle with 3 rows and 5 columns, filled with '*'
Iterating through multidimensional arrays
Nested loops are also helpful when we want to iterate through a multi dimensional array, for example:
vector> arr = {
{1, 2},
{3, 4},
{5, 6}
};
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 2; j++) {
cout << arr[i][j] << "\n";
}
}
// This outputs each sub-element in arr one at a time
Breaking nested loops
In a nested loop, a break statement only stops the loop it is placed in. Therefore, if a break is placed in the inner loop, the outer loop still continues. For example:
vector> arr = {
{1, 2},
{3, 4},
{5, 6}
};
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 2; j++) {
if(arr[i][j] == 3) {
break;
}
cout << arr[i][j] << "\n";
}
}
// prints the numbers 1, 2, 5 and 6 on different lines
When i is 1 and j is 0, we execute the break. This means we stop the inner loop and go back to the outer loop to continue from the next iteration, which is i = 2. And as you can see, we print all the elements of row 2.
However, if the break is placed in the outer loop, all of the looping stops. For example:
vector> arr = {
{1, 2},
{3, 4},
{5, 6}
};
for (int i = 0; i < 3; i++) {
if(arr[i][0] == 3) {
break;
}
for (int j = 0; j < 2; j++) {
cout << arr[i][j] << "\n";
}
}
// prints the numbers 1 and 2 on different lines
Assignment
Follow the Coding Tutorial and let's write some nested loops.
Hint
Look at the examples above if you get stuck.
Nested loops are a fundamental concept in programming, especially in C++. They are used to perform repeated actions within repeated actions, making them essential for tasks that involve multi-dimensional data structures or complex iteration patterns. Understanding nested loops is crucial for solving problems related to matrices, grids, and other multi-dimensional arrays.
Before diving into nested loops, it's important to understand the basic structure of a loop. A loop allows you to execute a block of code multiple times. In C++, the most common types of loops are for, while, and do-while loops. Nested loops are simply loops within loops, where the inner loop completes all its iterations for each iteration of the outer loop.
Here's a simple example to illustrate a basic loop:
for(int i = 0; i < 5; i++) {
cout << i << " ";
}
// Output: 0 1 2 3 4
Nested loops are used to handle multi-dimensional data structures. For example, a 2D array can be thought of as an array of arrays. To iterate through each element of a 2D array, you need a nested loop:
vector> arr = {
{1, 2},
{3, 4},
{5, 6}
};
for (int i = 0; i < arr.size(); i++) {
for (int j = 0; j < arr[i].size(); j++) {
cout << arr[i][j] << " ";
}
cout << endl;
}
// Output:
// 1 2
// 3 4
// 5 6
Nested loops are particularly useful in scenarios such as:
Let's look at an example of matrix addition:
vector> matrix1 = {
{1, 2},
{3, 4}
};
vector> matrix2 = {
{5, 6},
{7, 8}
};
vector> result(2, vector(2, 0));
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
result[i][j] = matrix1[i][j] + matrix2[i][j];
}
}
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
cout << result[i][j] << " ";
}
cout << endl;
}
// Output:
// 6 8
// 10 12
When working with nested loops, it's easy to make mistakes such as:
Best practices include:
Advanced techniques involve optimizing nested loops for performance. For example, you can use loop unrolling to reduce the overhead of loop control. Another technique is to use parallel processing to distribute the work of nested loops across multiple CPU cores.
Here's an example of loop unrolling:
for (int i = 0; i < n; i += 4) {
a[i] = b[i] + c[i];
a[i+1] = b[i+1] + c[i+1];
a[i+2] = b[i+2] + c[i+2];
a[i+3] = b[i+3] + c[i+3];
}
Let's implement a nested loop to print a multiplication table:
#include <iostream>
using namespace std;
int main() {
int n = 5;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cout << i * j << "\t";
}
cout << endl;
}
return 0;
}
// Output:
// 1 2 3 4 5
// 2 4 6 8 10
// 3 6 9 12 15
// 4 8 12 16 20
// 5 10 15 20 25
Debugging nested loops can be challenging. Here are some tips:
For testing, write test cases that cover different scenarios, including edge cases. For example, test with empty arrays, single-element arrays, and large arrays.
When approaching problems that require nested loops:
Practice is key to mastering nested loops. Try solving problems on coding challenge platforms to improve your skills.
Nested loops are a powerful tool in C++ programming. They allow you to handle multi-dimensional data structures and perform complex iterations. By understanding the basics, avoiding common pitfalls, and practicing regularly, you can become proficient in using nested loops effectively.
For further reading and practice, check out these resources: