Pointer arithmetic in C++ - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a pointer to an integer variable.

C++

int x = 10;
int* [1] = &x;

Drag options to blanks, or click blank then click option'

Aptr

Bref

Cp

Dpointer

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name that is a reserved keyword.

Forgetting the asterisk (*) to declare a pointer.

The pointer variable name can be any valid identifier. Here, 'p' is used as the pointer name.

2fill in blank

medium

Complete the code to increment the pointer to point to the next integer in memory.

C++

int arr[3] = {1, 2, 3};
int* p = arr;
p [1];

Drag options to blanks, or click blank then click option'

A--

B++

C+=

D-=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '--' which moves the pointer backwards.

Using '+=' without a value.

Using '++' increments the pointer to the next integer in the array.

3fill in blank

hard

Fix the error in the code to correctly access the second element using pointer arithmetic.

C++

int arr[3] = {10, 20, 30};
int* p = arr;
int val = *(p [1] 1);

Drag options to blanks, or click blank then click option'

A+

B-

C/

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' which moves the pointer backwards.

Using '*' or '/' which are invalid for pointer arithmetic.

Adding 1 to the pointer moves it to the second element, then dereferencing gets its value.

4fill in blank

hard

Fill both blanks to create a pointer that points to the third element and then decrement it.

C++

int arr[4] = {5, 10, 15, 20};
int* p = arr [1] 2;
p [2];

Drag options to blanks, or click blank then click option'

A+

B-

C--

D++

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' instead of '+' to move forward.

Using '++' instead of '--' to decrement.

Adding 2 moves pointer to third element; '--' decrements pointer to second element.

5fill in blank

hard

Fill all three blanks to create a pointer to the first element, move it forward by one, and then access the value.

C++

int arr[3] = {100, 200, 300};
int* [1] = arr;
[1] [2];
int val = *[3];

Drag options to blanks, or click blank then click option'

Ap

B++

Dq

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names for the pointer.

Forgetting to increment the pointer before dereferencing.

Pointer 'p' is declared, incremented, then dereferenced to get the second element's value.

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