Pointer arithmetic - Step-by-Step Execution

Concept Flow - Pointer arithmetic

Declare pointer p

↓

Assign address of array element to p

↓

Perform arithmetic: p + n

↓

Pointer points to new element

↓

Dereference *p to access value

↓

Use or print value

↓

End or repeat with new pointer

Pointer arithmetic moves the pointer to different elements in an array by adding or subtracting integers, then accessing the value at the new location.

Execution Sample

C

int arr[3] = {10, 20, 30};
int *p = arr;
int val1 = *p;
p += 1;
int val2 = *p;
p += 1;
int val3 = *p;

This code sets a pointer to the start of an array and accesses each element by moving the pointer with arithmetic.

Execution Table

Step	Pointer p	Expression	Dereferenced Value	Explanation
1	arr (address of arr[0])	*p	10	Pointer p points to arr[0], value 10 accessed
2	arr + 1 (address of arr[1])	*p	20	Pointer moved to arr[1], value 20 accessed
3	arr + 2 (address of arr[2])	*p	30	Pointer moved to arr[2], value 30 accessed
4	arr + 3	*p	Undefined behavior	Pointer moved beyond array bounds, accessing invalid memory

💡 Pointer arithmetic beyond array size leads to undefined behavior; execution stops after valid accesses.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4
p	arr (address of arr[0])	arr	arr + 1	arr + 2	arr + 3
*p	N/A	10	20	30	Undefined behavior

Key Moments - 2 Insights

Why does *p cause a problem?

Because the array has only 3 elements (indices 0 to 2), *p points outside the array, causing undefined behavior as shown in execution_table row 4.

Does adding 1 to a pointer increase its address by 1 byte?

No, adding 1 to a pointer moves it to the next element of its type, so the address increases by the size of the element (e.g., 4 bytes for int), as seen in the pointer values in variable_tracker.

Visual Quiz - 3 Questions

Look at the execution_table, what value does *p give at step 2?

A 20

B 30

C 10

D Undefined

💡 Hint

Check the 'Dereferenced Value' column at step 2 in execution_table.

At which step does pointer arithmetic go beyond the array bounds?

A Step 2

B Step 4

C Step 3

D Step 1

💡 Hint

Look at the 'Explanation' column in execution_table for the step where undefined behavior occurs.

If the array elements were of type char (1 byte), how would pointer arithmetic change?

A Pointer increments by 4 bytes

B Pointer increments by 2 bytes

C Pointer increments by 1 byte

D Pointer does not increment

💡 Hint

Pointer arithmetic moves by the size of the data type; char is 1 byte.

Concept Snapshot

Pointer arithmetic in C:
- Pointer + n moves pointer by n elements (not bytes)
- *p accesses value at pointer
- Pointer must point within array bounds
- Going outside array causes undefined behavior
- Pointer arithmetic depends on data type size

Full Transcript

Pointer arithmetic lets you move a pointer through an array by adding numbers. When you add 1 to a pointer, it moves to the next element, not just one byte. For example, if you have an int array, adding 1 moves the pointer by 4 bytes (size of int). You can then use *p to get the value at the pointer. But be careful: if you move the pointer beyond the array size, you get undefined behavior, which can cause errors. The example code shows a pointer moving through an array of three ints, accessing each value correctly, then going out of bounds at the end.

Practice

1. What does adding 1 to a pointer in C do?
int *p;

easy

A. Causes a syntax error

B. Moves the pointer by 1 byte

C. Moves the pointer to the previous element

D. Moves the pointer to the next element of the type it points to

Solution

1. Step 1: Understand pointer arithmetic basics

   In C, 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 the given pointer

   Since p is an int*, p + 1 points to the next int in memory.

3. Final Answer:

   Moves the pointer to the next element of the type it points to -> Option D

4. Quick Check:

   Pointer + 1 moves by element size [OK]

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

Common Mistakes:

• Thinking pointer arithmetic moves by 1 byte
• Confusing pointer increment with value increment
• Assuming pointer addition causes errors

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

int arr[5];
int *p = arr;

easy

A. p + 2

B. p ++ 2

C. p + ++ 2

D. p +* 2

Solution

1. Step 1: Review pointer arithmetic syntax

   Valid pointer arithmetic uses p + n or p - n where n is an integer.

2. Step 2: Check each option

   p + 2 is valid syntax. Options A, C, and D contain invalid operators or spacing causing syntax errors.

3. Final Answer:

   p + 2 -> Option A

4. Quick Check:

   Correct pointer addition syntax is p + n [OK]

Hint: Pointer arithmetic uses '+' or '-' with integers only [OK]

Common Mistakes:

• Using invalid operators like '++' incorrectly
• Adding spaces that change meaning
• Confusing pointer increment with addition

3. What is the output of this code?

int arr[] = {10, 20, 30, 40};
int *p = arr;
printf("%d", *(p + 2));

medium

A. 10

B. 20

C. 30

D. 40

Solution

1. Step 1: Understand pointer and array relation

   Pointer p points to arr[0], which is 10.

2. Step 2: Calculate pointer offset

   *(p + 2) accesses the element 2 positions after arr[0], which is arr[2] = 30.

3. Final Answer:

   30 -> Option C

4. Quick Check:

   Pointer + 2 points to third element = 30 [OK]

Hint: *(p + n) accesses nth element after pointer [OK]

Common Mistakes:

• Confusing index starting at 1 instead of 0
• Dereferencing pointer without offset
• Mixing pointer arithmetic with array indexing

4. Identify the error in this code snippet:

int arr[3] = {1, 2, 3};
int *p = arr + 3;
printf("%d", *p);

medium

A. Syntax error in pointer declaration

B. Pointer points beyond array bounds causing undefined behavior

C. Missing semicolon after array initialization

D. Incorrect printf format specifier

Solution

1. Step 1: Analyze pointer assignment

   p = arr + 3 points to one element past the last valid element (index 3 in a 3-element array).

2. Step 2: Understand dereferencing invalid pointer

   Dereferencing *p here causes undefined behavior because it accesses memory outside the array.

3. Final Answer:

   Pointer points beyond array bounds causing undefined behavior -> Option B

4. Quick Check:

   Pointer must not dereference beyond array end [OK]

Hint: Pointer + array size points just past array, not valid to dereference [OK]

Common Mistakes:

• Assuming pointer can safely dereference past array end
• Confusing pointer arithmetic with array length
• Ignoring undefined behavior risks

5. Given two pointers int *p1 and int *p2 pointing inside the same array, what does p2 - p1 represent?

hard

A. The number of elements between the two pointers

B. The difference in memory addresses as a raw number

C. The number of bytes between the two pointers

D. A syntax error because pointers cannot be subtracted

Solution

1. Step 1: Understand pointer subtraction in C

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

2. Step 2: Apply to pointers inside the same array

   Since p1 and p2 point inside the same array, p2 - p1 counts how many elements separate them.

3. Final Answer:

   The number of elements between the two pointers -> Option A

4. Quick Check:

   Pointer subtraction = element count difference [OK]

Hint: Pointer subtraction counts elements, not bytes [OK]

Common Mistakes:

• Thinking subtraction returns byte difference
• Assuming pointer subtraction is invalid
• Confusing pointer subtraction with pointer addition