Pointer arithmetic in C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is pointer arithmetic in C++?

Pointer arithmetic means adding or subtracting integers to or from pointers to move through memory locations of the pointed data type.

beginner

How does adding 1 to a pointer affect its value?

Adding 1 to a pointer moves it to the next element of its type, not just the next byte. For example, if it points to an int (4 bytes), adding 1 moves it 4 bytes forward.

intermediate

What happens when you subtract two pointers?

Subtracting two pointers gives the number of elements between them, assuming they point to elements of the same array.

beginner

Why can't you add two pointers together?

Adding two pointers is not allowed because it doesn't make sense to combine two memory addresses. Pointer arithmetic only supports adding or subtracting integers to pointers.

beginner

Example: If int* p points to address 1000 and sizeof(int) is 4, what is the address after p + 3?

The address will be 1000 + 3 * 4 = 1012 because pointer arithmetic moves in steps of the size of the pointed type.

What does adding 2 to a pointer of type double* do?

A Moves the pointer forward by 2 bytes

B Moves the pointer forward by 2 times the size of double

C Moves the pointer backward by 2 bytes

D Causes a compilation error

Adding 2 to a double* pointer moves it forward by 2 times the size of double in memory.

What is the result of subtracting two pointers pointing inside the same array?

A The difference in bytes between the two addresses

B Undefined behavior

C The number of elements between the two pointers

D The sum of the two pointers

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

Which of the following is NOT allowed in pointer arithmetic?

A Adding two pointers

B Subtracting an integer from a pointer

C Adding an integer to a pointer

D Subtracting two pointers

Adding two pointers is not allowed in C++ pointer arithmetic.

If p is an int* pointing to address 2000 and sizeof(int) is 4, what address does p - 1 point to?

A 2004

B 1999

C 2001

D 1996

Subtracting 1 moves the pointer back by 4 bytes, so 2000 - 4 = 1996.

Why is pointer arithmetic useful?

A To navigate through elements in arrays efficiently

B To perform math on memory addresses directly

C To convert pointers to integers

D To multiply pointers

Pointer arithmetic helps move through array elements by adjusting the pointer by element sizes.

Explain how pointer arithmetic works when adding an integer to a pointer.

Think about how arrays are stored in memory.

Describe what happens when you subtract two pointers pointing to elements in the same array.

Consider how many steps separate the two pointers.

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