Pointer arithmetic in C++ - Mini Project: Build & Apply

Pointer Arithmetic Basics

📖 Scenario: You are working with a list of daily temperatures stored in an array. You want to use pointers to access and manipulate these temperatures.

🎯 Goal: Learn how to use pointer arithmetic to access elements in an array and print their values.

📋 What You'll Learn

Create an integer array with exact values

Create a pointer to the first element of the array

Use pointer arithmetic to access array elements

Print the values accessed by the pointer

💡 Why This Matters

🌍 Real World

Pointer arithmetic is used in low-level programming to efficiently access and manipulate data stored in arrays or buffers.

💼 Career

Understanding pointers and pointer arithmetic is essential for systems programming, embedded development, and performance-critical applications.

1

Create an integer array

Create an integer array called temps with these exact values: 23, 25, 21, 19, 22.

C++

// Create the integer array 'temps' with the given values
// Your code here

Hint

Use curly braces to list the values inside the array declaration.

2

Create a pointer to the array

Create a pointer to int called ptr and set it to point to the first element of the temps array.

C++

int temps[] = {23, 25, 21, 19, 22};
// Create a pointer 'ptr' that points to the first element of 'temps'
// Your code here

Hint

Set the pointer equal to the array name to point to its first element.

3

Use pointer arithmetic to access elements

Use pointer arithmetic with ptr to access the third element of the array and store it in an integer variable called third_temp.

C++

int temps[] = {23, 25, 21, 19, 22};
int* ptr = temps;
// Use pointer arithmetic to get the third element and store in 'third_temp'
// Your code here

Hint

Remember that array indexing starts at 0, so the third element is at index 2.

4

Print the accessed value

Print the value of third_temp using std::cout.

C++

#include 

int main() {
    int temps[] = {23, 25, 21, 19, 22};
    int* ptr = temps;
    int third_temp = *(ptr + 2);
    // Print the value of 'third_temp'
    // Your code here
    return 0;
}

Hint

Use std::cout << third_temp << std::endl; to print the 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