Quartz 4

C++ array iteration for beginners 🗃️

5 min read

Metadata

  • Date :: 12-04-2025
  • Tags :: cpp

Notes

Detailed Notes on Iterating Over an Array in C++

In C++, iterating over the elements of an array is a common task, and understanding the different approaches to achieve this will help you write more efficient and cleaner code. This guide will cover how to iterate over an array using a for loop, how to handle arrays dynamically, and introduce the sizeof operator to automatically adjust for changes in array size.

1. Basic Example: Iterating Over an Array Using a Simple Index

Let’s start with a simple example. Suppose we have an array of student names:

std::string students[] = {"Spongebob", "Patrick", "Squidward"};

To display each element of this array, one approach is to manually access each element by its index:

std::cout << "My first student is " << students[0] << std::endl;  // Spongebob
std::cout << "My second student is " << students[1] << std::endl; // Patrick
std::cout << "My third student is " << students[2] << std::endl;  // Squidward

This method works but isn’t efficient if you want to print all elements of the array, especially if the array size changes. For example, if we add a fourth student, like “Sandy”, we’d need to update the code manually to access the new element.

2. Improved Approach: Using a for Loop

A better approach is to use a for loop. This allows you to iterate through all the elements of the array without manually accessing each element. Here’s how we can do this:

int n = sizeof(students) / sizeof(students[0]);  // Calculate number of elements in array
for (int i = 0; i < n; i++) {
    std::cout << students[i] << std::endl;
}

Explanation:

  • The loop starts with i = 0, which points to the first element of the array (students[0]).
  • The condition i < n ensures that the loop runs as long as i is less than the number of elements in the array (n).
  • The counter i is incremented after each iteration, and in each iteration, the program prints the student at the current index i.

3. Using the sizeof Operator for Array Size

One challenge when iterating over an array is managing its size. If the array size changes, you have to adjust the loop condition manually. However, you can use the sizeof operator to automatically determine the size of the array.

To calculate the number of elements in an array, we can use:

int n = sizeof(students) / sizeof(students[0]);
  • sizeof(students) gives the total memory allocated for the array in bytes.
  • sizeof(students[0]) gives the size of one element in the array (in this case, the size of a std::string).
  • Dividing the total size of the array by the size of one element gives the total number of elements in the array.

Using this calculation in the for loop:

int n = sizeof(students) / sizeof(students[0]);
for (int i = 0; i < n; i++) {
    std::cout << students[i] << std::endl;
}

If you add or remove elements from the array, the sizeof operator will automatically adjust the loop’s condition without needing manual updates.

4. Handling Dynamic Arrays

The sizeof method works well for statically sized arrays, but for dynamically allocated arrays (using new), it’s not as straightforward. When working with dynamically allocated memory, sizeof will give the size of the pointer, not the actual array size. In such cases, you’ll need to keep track of the size of the array yourself, typically by storing the size in a separate variable.

5. Example with a Character Array

Let’s look at an example where we iterate over an array of characters (grades):

char grades[] = {'A', 'B', 'C', 'D', 'F'};

To display each grade in the array, we can use a for loop, similar to how we iterated over the students array:

int n = sizeof(grades) / sizeof(grades[0]);  // Calculate number of elements in array
for (int i = 0; i < n; i++) {
    std::cout << grades[i] << std::endl;
}

This loop will print:

A
B
C
D
F

Since each char takes up 1 byte, the size of the entire array will be the number of elements (5 in this case).

6. Advantages of Using sizeof in Loops

Using sizeof to determine the size of an array is particularly useful because:

  • It makes the code more flexible: If you add or remove elements from the array, you don’t need to manually update the loop’s condition.
  • It minimizes errors: Manually counting elements or hardcoding values can lead to mistakes when the array changes. Using sizeof avoids this issue.
  • It works with different data types: Whether you are working with integers, characters, or strings, sizeof will give you the correct size of the array.

7. Limitations and Considerations

  • Dynamic arrays: As mentioned earlier, sizeof doesn’t work for dynamically allocated arrays because it only returns the size of the pointer, not the actual allocated memory.
  • Pointers to arrays: If you have a pointer to an array, sizeof will give the size of the pointer, not the array itself. In this case, you need to manage the size separately.

8. For-Each Loop (Upcoming Topic)

While the for loop is useful for iterating over arrays, C++ also offers a more concise way to iterate over arrays using the for-each loop. The for-each loop eliminates the need for manually maintaining the index and is more readable. This will be covered in the next topic, but it’s worth noting that the for-each loop is typically used with containers like arrays and vectors.

Conclusion

Iterating over arrays in C++ can be done efficiently using a for loop. By combining the for loop with the sizeof operator, you can dynamically adjust to changes in the array’s size without needing to modify the loop manually. This approach ensures that your code is flexible, less error-prone, and can handle arrays of different types and sizes efficiently.

References

Graph View

Backlinks