C++ Program To Access Elements Of An Array Using Pointer

Accessing elements in C++ arrays is a fundamental operation. While direct indexing like array[index] is common, using pointers offers a powerful and flexible alternative, especially for performance optimization and dynamic memory management. In this article, you will learn how to effectively access array elements using pointers in C++.

Problem Statement

Traditional array access using the subscript operator [] is straightforward for fixed-size arrays where the index is known. However, in scenarios involving dynamic memory allocation, iterating through large datasets, or when passing arrays to functions, relying solely on array indexing can sometimes be less efficient or less flexible than pointer arithmetic. Understanding pointer-based access provides a deeper understanding of memory management and enables more advanced programming techniques.

Example

Consider a simple array where we want to access its elements directly using indexing. This is the standard approach before introducing pointers.

// Direct Array Access
#include <iostream>
using namespace std;

int main() {
    int numbers[] = {10, 20, 30, 40, 50}; // Declare and initialize an integer array
    int size = sizeof(numbers) / sizeof(numbers[0]);

    cout << "Accessing elements using direct indexing:" << endl;
    for (int i = 0; i < size; ++i) {
        cout << "Element at index " << i << ": " << numbers[i] << endl;
    }

    return 0;
}

Run

Sample output:

Accessing elements using direct indexing:
Element at index 0: 10
Element at index 1: 20
Element at index 2: 30
Element at index 3: 40
Element at index 4: 50

Background & Knowledge Prerequisites

To understand array access with pointers, readers should be familiar with:

• C++ Basics: Fundamental syntax, variable declaration, loops (for, while).
• Arrays: Declaration, initialization, and basic indexing.
• Pointers:
• Declaration and initialization of pointers.
• The address-of operator (&) to get the memory address of a variable.
• The dereference operator (*) to access the value at a memory address.
• Basic pointer arithmetic (incrementing/decrementing pointers).

Use Cases or Case Studies

Pointers offer significant advantages in several array-related scenarios:

• Dynamic Memory Allocation: When arrays are created on the heap using new, they return a pointer to the first element. Pointers are essential for managing and accessing these dynamically allocated arrays.
• Function Arguments: Arrays passed to functions often decay into pointers to their first element. Using pointers inside the function provides a consistent way to access and manipulate array data.
• Efficient Iteration: For large arrays, pointer arithmetic can sometimes lead to slightly more optimized code compared to array indexing, as it directly manipulates memory addresses.
• Implementing Data Structures: Pointers are fundamental to building complex data structures like linked lists, trees, and graphs, where elements are not necessarily stored contiguously in memory but are linked via addresses.
• Low-Level Memory Manipulation: Pointers allow direct interaction with memory addresses, which is crucial for tasks like memory mapping, direct hardware access, or optimizing performance-critical sections of code.

Solution Approaches

Here are a few common approaches to accessing array elements using pointers.

Approach 1: Using a Pointer to the First Element (Basic Offset Access)

This approach involves declaring a pointer, making it point to the first element of the array, and then accessing subsequent elements by adding an offset to the pointer.

// Pointer to First Element Access
#include <iostream>
using namespace std;

int main() {
    // Step 1: Declare and initialize an integer array
    int numbers[] = {10, 20, 30, 40, 50};
    int size = sizeof(numbers) / sizeof(numbers[0]);

    // Step 2: Declare an integer pointer and make it point to the first element of the array
    // The name of an array (without brackets) decays to a pointer to its first element.
    int* ptr = numbers; 
    // Alternatively, you could use: int* ptr = &numbers[0];

    // Step 3: Access elements using pointer arithmetic (ptr + index) and dereference
    cout << "Accessing elements using a pointer to the first element (offset method):" << endl;
    for (int i = 0; i < size; ++i) {
        cout << "Element at index " << i << ": " << *(ptr + i) << endl;
    }

    return 0;
}

Run

Sample output:

Accessing elements using a pointer to the first element (offset method):
Element at index 0: 10
Element at index 1: 20
Element at index 2: 30
Element at index 3: 40
Element at index 4: 50

Stepwise Explanation:

1. An integer array numbers is declared and initialized.
2. An integer pointer ptr is declared. By assigning numbers (the array name) to ptr, ptr now holds the memory address of the first element (numbers[0]).
3. A for loop iterates from 0 to size - 1.
4. Inside the loop, (ptr + i) calculates the memory address of the i-th element relative to the start of the array. The + operator for pointers automatically scales by the size of the data type (e.g., if ptr points to an int, ptr + 1 moves 4 bytes ahead on most systems).
5. The * (dereference) operator retrieves the value stored at that calculated memory address.

Approach 2: Incrementing a Pointer for Traversal

This method involves initializing a pointer to the start of the array and then incrementing the pointer in each iteration to move to the next element.

// Pointer Increment Traversal
#include <iostream>
using namespace std;

int main() {
    // Step 1: Declare and initialize an integer array
    int numbers[] = {10, 20, 30, 40, 50};
    int size = sizeof(numbers) / sizeof(numbers[0]);

    // Step 2: Declare an integer pointer and initialize it to point to the first element
    int* currentPtr = numbers;

    // Step 3: Iterate through the array by incrementing the pointer
    cout << "Accessing elements by incrementing a pointer:" << endl;
    for (int i = 0; i < size; ++i) {
        cout << "Element " << i << ": " << *currentPtr << endl; // Dereference currentPtr to get the value
        currentPtr++; // Increment currentPtr to point to the next element
    }

    return 0;
}

Run

Sample output:

Accessing elements by incrementing a pointer:
Element 0: 10
Element 1: 20
Element 2: 30
Element 3: 40
Element 4: 50

Stepwise Explanation:

1. An integer array numbers is declared and initialized.
2. An integer pointer currentPtr is initialized to point to the first element of numbers.
3. The for loop iterates size times.
4. Inside the loop, *currentPtr directly dereferences the pointer to get the value at its current memory location.
5. currentPtr++ increments the pointer. Due to pointer arithmetic, this advances the pointer by sizeof(int) bytes, making it point to the next integer element in the array. This continues until all elements have been accessed.

Approach 3: Array Name as a Pointer (Syntactic Sugar)

In C++, the name of an array, when used without an index, often decays into a pointer to its first element. This allows us to use pointer arithmetic directly with the array name itself.

// Array Name as Pointer Access
#include <iostream>
using namespace std;

int main() {
    // Step 1: Declare and initialize an integer array
    int numbers[] = {10, 20, 30, 40, 50};
    int size = sizeof(numbers) / sizeof(numbers[0]);

    // Step 2: Access elements directly using the array name with pointer arithmetic
    cout << "Accessing elements using array name as a pointer:" << endl;
    for (int i = 0; i < size; ++i) {
        // (numbers + i) is equivalent to &numbers[i]
        // *(numbers + i) is equivalent to numbers[i]
        cout << "Element at index " << i << ": " << *(numbers + i) << endl;
    }

    return 0;
}

Run

Sample output:

Accessing elements using array name as a pointer:
Element at index 0: 10
Element at index 1: 20
Element at index 2: 30
Element at index 3: 40
Element at index 4: 50

Stepwise Explanation:

1. An integer array numbers is declared and initialized.
2. The for loop iterates size times.
3. Inside the loop, (numbers + i) performs pointer arithmetic directly on the array name. Since numbers (without an index) behaves as a pointer to its first element, (numbers + i) calculates the address of the i-th element.
4. *(numbers + i) dereferences this calculated address to retrieve the value. This demonstrates the close relationship between array indexing and pointer arithmetic in C++. In fact, array[i] is often internally translated by the compiler to *(array + i).

Conclusion

Accessing array elements using pointers is a fundamental concept in C++ that provides flexibility and can be more efficient in certain contexts than traditional array indexing. Whether you're working with dynamic memory, passing arrays to functions, or simply looking for alternative ways to traverse data, understanding pointer arithmetic is crucial. These approaches empower you to manipulate data at a lower level, leading to more robust and optimized code.

Summary

• Pointers vs. Indexing: While array[i] is convenient, pointers (*(ptr + i) or *ptr++) offer deeper memory control.
• Array Name Decay: An array name without an index (numbers) acts as a pointer to its first element (&numbers[0]).
• Pointer Arithmetic: Adding an integer to a pointer (ptr + i) correctly moves the pointer by i times the size of the pointed-to type.
• Dereferencing: Use the * operator to retrieve the value stored at the address a pointer holds.
• Use Cases: Essential for dynamic memory, function arguments, and building complex data structures.