Address and dereference operators in C++ - Step-by-Step Execution

Concept Flow - Address and dereference operators

Declare variable x

↓

Use & operator to get address of x

↓

Store address in pointer p

↓

Use * operator to access value at address p

↓

Read or modify value through *p

↓

End

This flow shows how a variable's address is taken with & and accessed or changed using *.

Execution Sample

C++

int x = 10;
int* p = &x;
int y = *p;
*p = 20;

This code stores x's address in p, reads x through *p into y, then changes x via *p.

Execution Table

Step	Code Line	Action	Variable States	Output/Effect
1	int x = 10;	Declare x and set to 10	x=10	x initialized to 10
2	int* p = &x;	Store address of x in pointer p	p=&x (address), x=10	p points to x
3	int y = *p;	Dereference p to get value of x, assign to y	y=10, p=&x, x=10	y gets value 10
4	*p = 20;	Change value at address p points to (x) to 20	x=20, y=10, p=&x	x updated to 20 via pointer
5	End	Program ends	x=20, y=10, p=&x	Final values set

💡 Program ends after modifying x through pointer *p.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
x	undefined	10	10	10	20	20
p	undefined	undefined	&x	&x	&x	&x
y	undefined	undefined	undefined	10	10	10

Key Moments - 3 Insights

Why does *p give the value of x?

Because p stores the address of x (see step 2), *p accesses the value at that address (step 3).

What happens when we do *p = 20?

It changes the value stored at the address p points to, which is x (step 4), so x becomes 20.

Is p the value of x?

No, p holds the address of x, not x's value itself (step 2). To get x's value via p, we use *p.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of y after step 3?

A 20

B Address of x

C 10

D Undefined

💡 Hint

Check the 'Variable States' column at step 3 in the execution table.

At which step does the value of x change?

A Step 4

B Step 3

C Step 2

D Step 1

💡 Hint

Look for the step where '*p = 20;' is executed in the code line column.

If we changed 'int* p = &x;' to 'int* p = nullptr;', what would happen when we do '*p = 20;'?

A x would become 20

B Program would crash or undefined behavior

C y would become 20

D Nothing changes, safe operation

💡 Hint

Dereferencing a null pointer (*p when p is nullptr) causes a runtime error.

Concept Snapshot

Address operator (&) gets a variable's memory address.
Dereference operator (*) accesses or changes the value at that address.
Use & to assign pointer, * to read or write through pointer.
Pointers hold addresses, not values.
Changing *pointer changes the original variable.

Full Transcript

This example shows how to use the address operator & and dereference operator * in C++. First, we declare an integer x with value 10. Then, we create a pointer p that stores the address of x using &x. Next, we read the value of x through the pointer by dereferencing p with *p and assign it to y. Finally, we change the value of x by assigning 20 to *p. The variable tracker shows how x changes from 10 to 20, while y remains 10. The key moments clarify that *p accesses the value at the address stored in p, and changing *p changes x. The visual quiz tests understanding of variable values at each step and what happens if p is null. This helps beginners see how pointers work step-by-step.