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.

Practice

1. What does the & operator do in C++?

easy

A. It dereferences a pointer to get the value.

B. It multiplies two numbers.

C. It declares a pointer variable.

D. It gives the memory address of a variable.

Solution

1. Step 1: Understand the & operator

   The & operator is used to get the address of a variable in memory.

2. Step 2: Differentiate from other operators

   It does not multiply, declare pointers, or dereference pointers; those are different operations.

3. Final Answer:

   It gives the memory address of a variable. -> Option D

4. Quick Check:

   & operator = address retrieval [OK]

Hint: Remember & means 'address of' in C++ [OK]

Common Mistakes:

• Confusing & with multiplication operator
• Thinking & declares a pointer
• Mixing & with dereference * operator

2. Which of the following is the correct way to declare a pointer to an integer 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 an int is declared as int *ptr; where * indicates pointer type.

2. Step 2: Check other options for syntax errors

   int &ptr; declares a reference, not a pointer. int ptr*; and *int ptr; are invalid syntax.

3. Final Answer:

   int *ptr; -> Option A

4. Quick Check:

   Pointer declaration = int *ptr; [OK]

Hint: Pointer syntax: type *name; [OK]

Common Mistakes:

• Using & instead of * for pointers
• Placing * after variable name incorrectly
• Confusing pointers with references

3. What is the output of the following code?

int x = 10;
int *p = &x;
*p = 20;
std::cout << x << std::endl;

medium

A. Address of x

B. 10

C. 20

D. Compilation error

Solution

1. Step 1: Understand pointer assignment

   Pointer p stores the address of x. Using *p = 20; changes the value at that address.

2. Step 2: Check the effect on x

   Since *p points to x, changing *p to 20 updates x to 20.

3. Final Answer:

   20 -> Option C

4. Quick Check:

   Dereferencing pointer changes original variable [OK]

Hint: Changing *p changes the value of x [OK]

Common Mistakes:

• Thinking *p is the address, not the value
• Expecting output to be original x (10)
• Confusing pointer variable with pointed value

4. Identify the error in this code snippet:

int x = 5;
int *p;
*p = x;
std::cout << *p << std::endl;

medium

A. Variable x is not declared.

B. Pointer p is not initialized before dereferencing.

C. Syntax error in pointer declaration.

D. Cannot assign value to *p.

Solution

1. Step 1: Check pointer initialization

   Pointer p is declared but not assigned an address before *p = x;.

2. Step 2: Understand dereferencing uninitialized pointer

   Dereferencing p without initialization causes undefined behavior or crash.

3. Final Answer:

   Pointer p is not initialized before dereferencing. -> Option B

4. Quick Check:

   Always initialize pointers before dereferencing [OK]

Hint: Initialize pointers before using *p [OK]

Common Mistakes:

• Dereferencing pointer without assigning address
• Assuming pointer auto-points to variable
• Confusing pointer declaration with initialization

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

int a = 3, b = 4;
int *p = &a;
int *q = &b;
int *temp = p;
p = q;
q = temp;
std::cout << *p << " " << *q << std::endl;

hard

A. 4 3

B. 3 4

C. 3 3

D. 4 4

Solution

1. Step 1: Understand pointer swapping

   Initially, p points to a (3), q points to b (4). The code swaps the pointers using temp.

2. Step 2: Check final pointer values

   After swapping, p points to b (4), and q points to a (3).

3. Final Answer:

   4 3 -> Option A

4. Quick Check:

   Pointer swap changes what they point to [OK]

Hint: Swapping pointers swaps the values they point to [OK]

Common Mistakes:

• Confusing swapping pointers with swapping values
• Expecting original order after swap
• Mixing pointer values and pointed values