Traversing 2-Dimensional Arrays Using Pointers in C++

In C++, arrays are powerful constructs for storing and accessing collections of elements of the same type. When dealing with multidimensional arrays, such as 2-dimensional arrays, traversing them efficiently becomes essential. Pointers offer a versatile approach to iterate through such arrays, providing flexibility and performance benefits. This article explores the concept of traversing 2-dimensional arrays using pointers in C++, followed by an example program and a detailed line-by-line explanation.

Understanding 2-Dimensional Arrays and Pointers

A 2-dimensional array in C++ is essentially an array of arrays, where each element is itself an array. This structure is commonly used to represent matrices, tables, or grids of data. Accessing elements in a 2-dimensional array involves specifying both row and column indices.

Pointers, on the other hand, are variables that hold memory addresses. They provide a way to access and manipulate data indirectly, which can be particularly useful when dealing with arrays and dynamic memory allocation.

Example Program: Traversing a 2-Dimensional Array

Let’s consider a simple example where we have a 3×3 matrix of integers, and we want to traverse through it using pointers.

#include <iostream>

int main() {
    const int rows = 3;
    const int cols = 3;
    int matrix[rows][cols] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };

    // Pointer to traverse the 2D array
    int *ptr = &matrix[0][0];

    // Traversing the 2D array using pointer arithmetic
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            std::cout << *(ptr + i * cols + j) << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

Explanation

We define a 2-dimensional array matrix with 3 rows and 3 columns, initialized with integer values using brace-enclosed initializer lists.
We declare a pointer ptr of type int and initialize it with the address of the first element of the matrix using &matrix[0][0]. This pointer now points to the beginning of the 2-dimensional array.
We traverse through the 2-dimensional array using nested for loops. The outer loop iterates over the rows, and the inner loop iterates over the columns.
Inside the nested loops, we use pointer arithmetic to access each element of the array. The expression *(ptr + i * cols + j) calculates the memory address of the element at position (i, j) in the 2-dimensional array. Here, i * cols + j calculates the offset from the base address ptr to the desired element, taking into account the row and column indices.
We print each element of the array separated by spaces and move to the next line after printing each row to maintain the matrix structure in the output.

Here are few more examples illustrating traversal of 2 dimensional arrays using pointers in C++

Traversing 2D Array Using Pointers – Calculate Total

Introduction: This program demonstrates how to traverse a 2D array using pointers and calculate the total sum of all elements.

#include <iostream>

int main() {
    const int rows = 3;
    const int cols = 4;
    int arr[rows][cols] = {{1, 2, 3, 4},
                           {5, 6, 7, 8},
                           {9, 10, 11, 12}};

    int *ptr = &arr[0][0]; // Pointer to the first element of the 2D array
    int total = 0;

    for (int i = 0; i < rows * cols; ++i) {
        total += *ptr; // Add value of current element to total
        ptr++; // Move pointer to the next element
    }

    std::cout << "Total sum: " << total << std::endl;

    return 0;
}

Explanation:

const int rows = 3; and const int cols = 4;: Specifies the number of rows and columns in the 2D array.
int arr[rows][cols] = { ... };: Declares and initializes a 2D array with specific values.
int *ptr = &arr[0][0];: Declares a pointer ptr and assigns it to the address of the first element of the 2D array.
int total = 0;: Initializes a variable total to store the sum of all elements.
for (int i = 0; i < rows * cols; ++i) { total += *ptr; ptr++; }: Iterates through each element of the 2D array using a single loop.
- total += *ptr;: Adds the value of the current element pointed to by ptr to the total sum.
- ptr++;: Moves the pointer ptr to the next element in the array.
std::cout << "Total sum: " << total << std::endl;: Prints the total sum of all elements.

The program above demonstrates how to traverse a 2D array using pointers and calculate the total sum of all elements.

Traversing 2D Array Using Pointers – Find Maximum Value

Introduction: This program demonstrates how to traverse a 2D array using pointers and find the maximum value among all elements.

#include <iostream>

int main() {
    const int rows = 3;
    const int cols = 4;
    int arr[rows][cols] = {{1, 2, 3, 4},
                           {5, 6, 7, 8},
                           {9, 10, 11, 12}};

    int *ptr = &arr[0][0]; // Pointer to the first element of the 2D array
    int max = *ptr; // Initialize max with the value of the first element

    for (int i = 1; i < rows * cols; ++i) {
        if (*(ptr + i) > max) {
            max = *(ptr + i); // Update max if current element is greater
        }
    }

    std::cout << "Maximum value: " << max << std::endl;

    return 0;
}

Explanation:

const int rows = 3; and const int cols = 4;: Specifies the number of rows and columns in the 2D array.
int arr[rows][cols] = { ... };: Declares and initializes a 2D array with specific values.
int *ptr = &arr[0][0];: Declares a pointer ptr and assigns it to the address of the first element of the 2D array.
int max = *ptr;: Initializes a variable max to store the maximum value and initializes it with the value of the first element.
for (int i = 1; i < rows * cols; ++i) { ... }: Iterates through each element of the 2D array using a single loop, starting from the second element.
- if (*(ptr + i) > max) { max = *(ptr + i); }: Compares the value of the current element pointed to by ptr + i with the current maximum value max and updates max if the current element is greater.
std::cout << "Maximum value: " << max << std::endl;: Prints the maximum value found.

This program demonstrates how to traverse a 2D array using pointers and find the maximum value among all elements.

These examples provide a detailed understanding of traversing 2-dimensional arrays using pointers in C++

Conclusion

Traversing 2-dimensional arrays using pointers in C++ offers an efficient and flexible approach to access elements of the array. By understanding how pointers and array indexing work together, you can efficiently iterate through multidimensional arrays, perform various operations, and manipulate data with ease. This capability is crucial for handling matrices, images, and other structured data efficiently in C++ programs.