Pointer arithmetic in C++

Introduction

Pointer arithmetic helps you move through memory locations easily. It lets you access elements in arrays or blocks of memory by adding or subtracting numbers to pointers.

When you want to loop through an array using pointers instead of indexes.

When working with dynamic memory and you need to move between allocated blocks.

When you want to access elements in a C-style string by moving the pointer.

When you need to calculate the distance between two memory addresses.

When optimizing code to work directly with memory locations.

Syntax

C++

pointer + n
pointer - n
pointer++
pointer--

Adding or subtracting an integer moves the pointer by that many elements, not bytes.

Increment (++) and decrement (--) move the pointer to the next or previous element.

Examples

Adding 2 moves the pointer to the third element in the array.

C++

int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;

p = p + 2;  // Points to arr[2], value 30

Incrementing pointer moves to the next character in the string.

C++

char str[] = "hello";
char *p = str;

p++;  // Points to 'e' now

Subtracting pointers gives the number of elements between them.

C++

int *p1 = &arr[4];
int *p2 = &arr[1];

int diff = p1 - p2;  // diff is 3

Sample Program

This program shows how to move a pointer through an array and access elements by changing the pointer position.

C++

#include <iostream>

int main() {
    int numbers[] = {5, 10, 15, 20, 25};
    int *ptr = numbers;  // points to numbers[0]

    std::cout << "First element: " << *ptr << "\n";

    ptr = ptr + 3;  // move pointer to numbers[3]
    std::cout << "Fourth element: " << *ptr << "\n";

    ptr--;
    std::cout << "Third element after decrement: " << *ptr << "\n";

    int diff = ptr - numbers;  // distance from start
    std::cout << "Pointer is " << diff << " elements from start" << "\n";

    return 0;
}

Important Notes

Pointer arithmetic depends on the type size. For example, adding 1 to an int* moves by sizeof(int) bytes.

Be careful not to move pointers outside the array bounds; it causes undefined behavior.

Pointer subtraction only works if both pointers point to elements of the same array.

Summary

Pointer arithmetic lets you move through arrays by adding or subtracting numbers to pointers.

Increment and decrement operators move pointers to next or previous elements.

Subtracting pointers gives the number of elements between them.

Practice

1. What does adding 1 to a pointer in C++ do when the pointer points to an int array?

easy

A. Moves the pointer to the next integer element in the array

B. Increases the pointer's memory address by 1 byte

C. Moves the pointer to the next byte in memory

D. Causes a compilation error

Solution

1. Step 1: Understand pointer arithmetic basics

   Adding 1 to a pointer moves it to the next element of the type it points to, not just 1 byte.

2. Step 2: Apply to int pointer

   Since int usually occupies 4 bytes, adding 1 moves the pointer by 4 bytes to the next integer.

3. Final Answer:

   Moves the pointer to the next integer element in the array -> Option A

4. Quick Check:

   Pointer + 1 = next element [OK]

Hint: Pointer + 1 moves to next element, not next byte [OK]

Common Mistakes:

• Thinking pointer arithmetic adds 1 byte always
• Confusing pointer increment with byte increment
• Assuming pointer arithmetic causes errors

2. Which of the following pointer arithmetic expressions is syntactically correct in C++?

easy

A. 1 + ptr

B. All of the above

C. ptr - 1

D. ptr + 1

Solution

1. Step 1: Check pointer addition syntax

   Adding an integer to a pointer like ptr + 1 is valid and moves the pointer forward.

2. Step 2: Check commutativity and subtraction

   Integer + pointer like 1 + ptr is also valid due to commutativity. Pointer - integer like ptr - 1 moves pointer backward and is valid.

3. Final Answer:

   All of the above -> Option B

4. Quick Check:

   Pointer + int and int + pointer both valid [OK]

Hint: Pointer + int and int + pointer both work [OK]

Common Mistakes:

• Assuming int + pointer is invalid
• Thinking pointer - int is not allowed
• Confusing pointer arithmetic with pointer subtraction

3. What is the output of the following C++ code?

int arr[] = {10, 20, 30, 40};
int *p = arr;
int *q = arr + 3;
std::cout << q - p << std::endl;

medium

A. 3

B. 4

C. 30

D. Compilation error

Solution

1. Step 1: Understand pointer subtraction

   Subtracting two pointers gives the number of elements between them, not bytes.

2. Step 2: Calculate difference between pointers

   q = arr + 3 points to the 4th element, p = arr points to the 1st. Difference is 3 elements.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Pointer difference = number of elements [OK]

Hint: Pointer subtraction returns element count, not bytes [OK]

Common Mistakes:

• Thinking pointer subtraction returns byte difference
• Confusing pointer difference with array values
• Expecting compilation error

4. Identify the error in the following code snippet:

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

medium

A. Array size is incorrect

B. Syntax error in pointer initialization

C. Pointer points outside array bounds, causing undefined behavior

D. Dereferencing pointer is valid and prints 5

Solution

1. Step 1: Analyze pointer initialization

   p = arr + 5 points one past the last element (index 5), which is outside the array bounds.

2. Step 2: Check dereferencing pointer

   Dereferencing *p here is undefined behavior because pointer is out of valid range.

3. Final Answer:

   Pointer points outside array bounds, causing undefined behavior -> Option C

4. Quick Check:

   Dereferencing out-of-bounds pointer is unsafe [OK]

Hint: Pointer must not dereference beyond array end [OK]

Common Mistakes:

• Assuming pointer at arr+5 is valid to dereference
• Confusing pointer arithmetic with array indexing
• Ignoring undefined behavior risks

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

int arr[] = {5, 10, 15, 20, 25};
int *p = arr + 1;
int *q = arr + 4;
int diff = q - p;
std::cout << *(p + diff) << std::endl;

hard

A. Undefined behavior

B. 20

C. Compilation error

D. 25

Solution

1. Step 1: Calculate pointer difference

   q - p = (arr + 4) - (arr + 1) = 3 elements difference.

2. Step 2: Evaluate pointer arithmetic and dereference

   p + diff = (arr + 1) + 3 = arr + 4, which points to the element 25. Dereferencing gives 25.

3. Final Answer:

   25 -> Option D

4. Quick Check:

   Pointer arithmetic + dereference = correct element [OK]

Hint: Pointer difference + pointer = new pointer position [OK]

Common Mistakes:

• Confusing pointer difference with value difference
• Miscalculating pointer arithmetic
• Assuming undefined behavior without reason