Pointers and arrays in C++

Introduction

Pointers let you directly access memory locations. Arrays are groups of items stored next to each other in memory. Using pointers with arrays helps you work with data efficiently.

When you want to loop through an array quickly using memory addresses.

When you need to pass large arrays to functions without copying all data.

When you want to access or modify array elements using pointer arithmetic.

When working with dynamic arrays created with manual memory allocation.

When you want to understand how data is stored and accessed in memory.

Syntax

C++

class PointerArrayExample {
public:
    void printArrayUsingPointer(int* array, int size) {
        for (int i = 0; i < size; i++) {
            // Access element using pointer arithmetic
            std::cout << *(array + i) << " ";
        }
        std::cout << std::endl;
    }

    void printArrayUsingIndex(int array[], int size) {
        for (int i = 0; i < size; i++) {
            // Access element using array index
            std::cout << array[i] << " ";
        }
        std::cout << std::endl;
    }
};

In C++, the name of an array acts like a pointer to its first element.

Pointer arithmetic means adding an integer to a pointer moves it to the next elements in memory.

Examples

Pointer points to the first element of the array. Using pointer + index accesses other elements.

C++

#include <iostream>

int main() {
    int numbers[3] = {10, 20, 30};
    int* pointerToNumbers = numbers; // points to first element

    std::cout << *pointerToNumbers << std::endl; // prints 10
    std::cout << *(pointerToNumbers + 1) << std::endl; // prints 20
    std::cout << *(pointerToNumbers + 2) << std::endl; // prints 30

    return 0;
}

Empty array has no elements. Pointer points to no valid data. Be careful not to dereference.

C++

#include <iostream>

int main() {
    // int emptyArray[0]; // zero-length arrays are not standard in C++
    int* pointerToEmpty = nullptr;

    // No elements to access, pointer points to no valid data
    std::cout << pointerToEmpty << std::endl; // prints address or nullptr

    return 0;
}

Array with one element. Pointer points to that single element.

C++

#include <iostream>

int main() {
    int singleElementArray[1] = {42};
    int* pointerToSingle = singleElementArray;

    std::cout << *pointerToSingle << std::endl; // prints 42

    return 0;
}

Shows accessing first and last elements using pointer arithmetic.

C++

#include <iostream>

int main() {
    int numbers[5] = {5, 10, 15, 20, 25};
    int* pointerToNumbers = numbers;

    // Access first element
    std::cout << *pointerToNumbers << std::endl; // 5

    // Access last element
    std::cout << *(pointerToNumbers + 4) << std::endl; // 25

    return 0;
}

Sample Program

This program shows two ways to print array elements: using pointers and using array indexes. Both print the same result.

C++

#include <iostream>

class PointerArrayExample {
public:
    void printArrayUsingPointer(int* array, int size) {
        std::cout << "Using pointer arithmetic: ";
        for (int i = 0; i < size; i++) {
            std::cout << *(array + i) << " ";
        }
        std::cout << std::endl;
    }

    void printArrayUsingIndex(int array[], int size) {
        std::cout << "Using array index: ";
        for (int i = 0; i < size; i++) {
            std::cout << array[i] << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    int numbers[5] = {100, 200, 300, 400, 500};
    PointerArrayExample example;

    std::cout << "Array elements:" << std::endl;
    example.printArrayUsingPointer(numbers, 5);
    example.printArrayUsingIndex(numbers, 5);

    return 0;
}

Important Notes

Time complexity to access any element by pointer or index is O(1).

Pointer arithmetic moves the pointer by the size of the data type automatically.

Common mistake: dereferencing pointers outside array bounds causes undefined behavior.

Use pointers when you want efficient access or to pass arrays to functions without copying.

Summary

Pointers can access array elements by moving through memory addresses.

Array name acts like a pointer to the first element.

Pointer arithmetic and array indexing both access elements but pointer arithmetic works with memory addresses directly.

Practice

1. What does the name of an array represent in C++?

easy

A. A copy of the entire array

B. The total size of the array

C. The last element of the array

D. A pointer to the first element of the array

Solution

1. Step 1: Understand array name behavior

   In C++, the name of an array acts as a pointer to its first element, not the whole array or size.

2. Step 2: Confirm pointer usage

   This pointer can be used to access elements by pointer arithmetic or indexing.

3. Final Answer:

   A pointer to the first element of the array -> Option D

4. Quick Check:

   Array name = pointer to first element [OK]

Hint: Remember array name points to element zero [OK]

Common Mistakes:

• Thinking array name stores size
• Confusing array name with last element
• Assuming array name copies data

2. Which of the following is the correct way to declare a pointer to an integer array named arr?

easy

A. int *ptr = &arr;

B. int ptr = &arr;

C. int *ptr = arr;

D. int ptr = arr;

Solution

1. Step 1: Understand pointer declaration

   To declare a pointer to an integer, use int *ptr. The array name arr acts as a pointer to its first element.

2. Step 2: Assign pointer correctly

   Assigning ptr = arr; sets the pointer to the first element's address. Using &arr gives the address of the whole array, which has a different type.

3. Final Answer:

   int *ptr = arr; -> Option C

4. Quick Check:

   Pointer to first element = int *ptr = arr [OK]

Hint: Use int *ptr = arr; to point to array start [OK]

Common Mistakes:

• Using &arr instead of arr for pointer
• Declaring pointer as int instead of int*
• Assigning pointer without *

3. What is the output of the following code?

int arr[] = {10, 20, 30};
int *p = arr;
std::cout << *(p + 1) << std::endl;

medium

A. 20

B. 10

C. 30

D. Compilation error

Solution

1. Step 1: Understand pointer arithmetic

   Pointer p points to arr[0]. Adding 1 moves pointer to arr[1].

2. Step 2: Dereference pointer at new position

   Dereferencing *(p + 1) gives the value at arr[1], which is 20.

3. Final Answer:

   20 -> Option A

4. Quick Check:

   *(p + 1) = arr[1] = 20 [OK]

Hint: Pointer + 1 points to next array element [OK]

Common Mistakes:

• Confusing pointer arithmetic with addition of values
• Dereferencing pointer without offset
• Expecting compilation error

4. Identify the error in the following code snippet:

int arr[3] = {1, 2, 3};
int *p = &arr;
std::cout << *(p + 2) << std::endl;

medium

A. Pointer declaration is correct, no error

B. Incorrect pointer assignment: &arr should be arr

C. Dereferencing pointer is invalid syntax

D. Array size is too small for pointer arithmetic

Solution

1. Step 1: Analyze pointer assignment

   arr is an array name acting as pointer to first element. &arr is address of whole array, type int (*)[3], incompatible with int *.

2. Step 2: Correct pointer assignment

   Assigning int *p = arr; is correct to point to first element. Using &arr causes type mismatch and incorrect pointer arithmetic.

3. Final Answer:

   Incorrect pointer assignment: &arr should be arr -> Option B

4. Quick Check:

   Use arr, not &arr, for int* pointer [OK]

Hint: Use arr, not &arr, when assigning int* pointer [OK]

Common Mistakes:

• Using &arr instead of arr for int*
• Ignoring pointer type mismatch warnings
• Assuming &arr points to first element

5. Given the code below, what will be the output?

int arr[] = {5, 10, 15, 20};
int *p = arr + 1;
std::cout << p[2] << std::endl;

hard

A. 20

B. 15

C. Undefined behavior

D. 10

Solution

1. Step 1: Understand pointer initialization

   p = arr + 1; points to arr[1], which is 10.

2. Step 2: Access element using pointer indexing

   p[2] means *(p + 2), which points to arr[3] (1 + 2 = 3), value 20.

3. Final Answer:

   20 -> Option A

4. Quick Check:

   p[2] = arr[3] = 20 [OK]

Hint: Pointer[index] = *(pointer + index) [OK]

Common Mistakes:

• Confusing p[2] with arr[2]
• Forgetting pointer offset starts at arr + 1
• Assuming p[2] is out of bounds