Pointers and arrays in C - Step-by-Step Execution

Concept Flow - Pointers and arrays

Declare array

→Array memory allocated

↓

Pointer declared

↓

Pointer assigned to array address

↓

Access elements via pointer

↓

Modify elements via pointer

↓

Pointer arithmetic to move through array

↓

End of access

This flow shows how an array is declared and how a pointer can be assigned to its address to access and modify elements using pointer arithmetic.

Execution Sample

C

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

This code declares an array, assigns a pointer to its start, and accesses the second element using pointer arithmetic.

Execution Table

Step	Action	Pointer p	Expression	Value Accessed	Array State
1	Declare array arr with values {10,20,30}	N/A	N/A	N/A	[10, 20, 30]
2	Declare pointer p	Uninitialized	N/A	N/A	[10, 20, 30]
3	Assign p = arr (address of arr[0])	Address of arr[0]	N/A	N/A	[10, 20, 30]
4	Access *(p + 1)	Address of arr[0]	*(p + 1)	20	[10, 20, 30]
5	Modify *(p + 2) = 40	Address of arr[0]	*(p + 2) = 40	40	[10, 20, 40]
6	Increment pointer p++	Address of arr[1]	p++	N/A	[10, 20, 40]
7	Access *p	Address of arr[1]	*p	20	[10, 20, 40]
8	End of access	Address of arr[1]	N/A	N/A	[10, 20, 40]

💡 Pointer arithmetic and array access complete; program ends.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 6	Final
arr	[10, 20, 30]	[10, 20, 30]	[10, 20, 40]	[10, 20, 40]	[10, 20, 40]
p	Uninitialized	Address of arr[0]	Address of arr[0]	Address of arr[1]	Address of arr[1]
val	Undefined	Undefined	20	20	20

Key Moments - 3 Insights

Why does *(p + 1) access the second element of the array?

Because p points to the first element, adding 1 moves the pointer to the next element in memory, so *(p + 1) dereferences the second element. See execution_table row 4.

What happens when we do p++ on the pointer?

The pointer moves to the next element in the array (address of arr[1]). It does not change the array contents. See execution_table row 6.

How does modifying *(p + 2) affect the array?

It changes the value at the third element of the array because (p + 2) points to arr[2]. The array updates accordingly. See execution_table row 5.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what value does *(p + 1) access?

A 10

B 20

C 30

D 40

💡 Hint

Check the 'Value Accessed' column at step 4 in execution_table.

At which step does the array value change from 30 to 40?

A Step 6

B Step 4

C Step 5

D Step 7

💡 Hint

Look at the 'Array State' column in execution_table to see when the last element changes.

After p++, what element does *p point to?

A arr[1]

B arr[0]

C arr[2]

D Undefined

💡 Hint

Check pointer p value in variable_tracker after step 6.

Concept Snapshot

Pointers and arrays:
- Array name is address of first element
- Pointer can point to array start
- *(p + i) accesses i-th element
- Pointer arithmetic moves by element size
- Modifying *p changes array content
- p++ moves pointer to next element

Full Transcript

This lesson shows how arrays and pointers work together in C. We start by declaring an array with three integers. Then we declare a pointer and assign it to the array's address, which points to the first element. Using pointer arithmetic, we access the second element with *(p + 1), which gives us 20. We also modify the third element by setting *(p + 2) to 40, changing the array's last value. Incrementing the pointer with p++ moves it to the second element. Accessing *p now gives 20. This step-by-step trace helps understand how pointers and arrays relate in memory.

Practice

1. What does a pointer to an array in C typically store?

easy

A. The address of the first element of the array

B. The total number of elements in the array

C. The sum of all elements in the array

D. The value of the last element in the array

Solution

1. Step 1: Understand pointer basics

   A pointer stores a memory address, not values or counts.

2. Step 2: Pointer to array points to first element

   In C, a pointer to an array points to the first element's address.

3. Final Answer:

   The address of the first element of the array -> Option A

4. Quick Check:

   Pointer = first element address [OK]

Hint: Pointers hold addresses, not values or counts [OK]

Common Mistakes:

• Thinking pointer stores array size
• Confusing pointer with array value
• Assuming pointer stores last element

2. Which of the following is the correct way to declare a pointer to an integer array in C?

easy

A. int ptr[];

B. int *ptr;

C. int &ptr;

D. int ptr*;

Solution

1. Step 1: Recall pointer declaration syntax

   In C, a pointer to int is declared as int *ptr;

2. Step 2: Check other options for syntax errors

   int ptr[] declares an array, not a pointer; int &ptr is invalid in C; int ptr* is incorrect syntax.

3. Final Answer:

   int *ptr; -> Option B

4. Quick Check:

   Pointer syntax uses * before variable [OK]

Hint: Pointer declaration uses * before variable name [OK]

Common Mistakes:

• Using array syntax instead of pointer
• Confusing C++ reference (&) with pointer
• Placing * after variable name incorrectly

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

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

medium

A. 10

B. 30

C. Garbage value

D. 20

Solution

1. Step 1: Understand pointer arithmetic

   p points to arr[0], so p + 1 points to arr[1].

2. Step 2: Dereference pointer at p + 1

   *(p + 1) gives value at arr[1], which is 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   *(p+1) = arr[1] = 20 [OK]

Hint: Pointer + 1 moves to next array element [OK]

Common Mistakes:

• Confusing *(p+1) with *p
• Assuming pointer arithmetic adds 1 byte
• Expecting arr[0] value instead

4. Identify the error in this C code snippet:

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

medium

A. Missing semicolon after array declaration

B. Array size is incorrect

C. Pointer points outside array bounds causing undefined behavior

D. Pointer declaration syntax is wrong

Solution

1. Step 1: Analyze pointer assignment

   arr + 3 points one element past the last array element (out of bounds).

2. Step 2: Dereferencing out-of-bounds pointer

   *p accesses invalid memory, causing undefined behavior.

3. Final Answer:

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

4. Quick Check:

   Pointer out of array range = error [OK]

Hint: Pointer must stay within array limits [OK]

Common Mistakes:

• Ignoring pointer out-of-bounds access
• Thinking array size is wrong
• Confusing pointer syntax errors

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

int arr[] = {5, 10, 15, 20};
int *p = arr;
for(int i = 0; i < 4; i++) {
    printf("%d ", *(p + i));
}

hard

A. 5 10 15 20

B. 20 15 10 5

C. 5 5 5 5

D. Compilation error

Solution

1. Step 1: Understand the loop and pointer arithmetic

   Loop runs i from 0 to 3, *(p + i) accesses arr[i].

2. Step 2: Print each element in order

   Values printed are arr[0]=5, arr[1]=10, arr[2]=15, arr[3]=20.

3. Final Answer:

   5 10 15 20 -> Option A

4. Quick Check:

   Pointer + i accesses arr[i] in order [OK]

Hint: Pointer + i accesses array element i [OK]

Common Mistakes:

• Assuming reverse order print
• Printing same element repeatedly
• Expecting syntax error