Address and dereference operators in Go - 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 dereference p

↓

Access or modify value at address

↓

End

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

Execution Sample

Go

package main
import "fmt"
func main() {
  x := 10
  p := &x
  fmt.Println(*p)
  *p = 20
  fmt.Println(x)
}

This code shows how to get the address of x, print its value via pointer p, change it through p, and print x again.

Execution Table

Step	Action	Variable	Value	Pointer Value	Output
1	Declare x	x	10	nil
2	Get address of x with &	x	10	address_of_x
3	Assign address to p	p	nil	address_of_x
4	Print *p (dereference p)	x	10	address_of_x	10
5	Set *p = 20 (change value at address)	x	20	address_of_x
6	Print x after change	x	20	address_of_x	20

💡 Program ends after printing updated value of x

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
x	undefined	10	10	20	20
p	nil	nil	address_of_x	address_of_x	address_of_x

Key Moments - 3 Insights

Why does changing *p also change x?

Because p holds the address of x, dereferencing *p accesses the same memory as x, so changing *p changes x (see steps 5 and 6).

What does the & operator do exactly?

The & operator gets the memory address of a variable, shown in step 2 where p gets the address of x.

Why do we use *p to print the value instead of just p?

p is a pointer holding an address; *p accesses the value at that address, so printing *p shows x's value (step 4).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of x after step 5?

A 20

B 10

C address_of_x

D nil

💡 Hint

Check the 'Value' column for x at step 5 in the execution_table.

At which step is the pointer p assigned the address of x?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Action' column describing pointer assignment in the execution_table.

If we print p instead of *p at step 4, what would be the output?

A 10

B 20

C address_of_x

D nil

💡 Hint

p holds the address; see the 'Pointer Value' column in the execution_table.

Concept Snapshot

Address and dereference operators in Go:
- & gets the address of a variable
- * dereferences a pointer to access or change the value
- Changing *p changes the original variable
- Use pointers to work with memory addresses directly

Full Transcript

This example shows how to use the address operator & to get a variable's memory address and store it in a pointer variable p. Then, using the dereference operator *, we access or modify the value at that address. Initially, x is 10. We assign p = &x, so p points to x's address. Printing *p shows 10. Changing *p to 20 updates x to 20. Printing x confirms the change. This demonstrates how pointers let us work directly with memory locations in Go.