Common pointer use cases in Go - Step-by-Step Execution

Concept Flow - Common pointer use cases

Declare variable

↓

Create pointer to variable

↓

Use pointer to read value

↓

Use pointer to modify value

↓

Pass pointer to function

↓

Function modifies original variable

↓

End

This flow shows how pointers are declared, used to read and modify values, and passed to functions to change original variables.

Execution Sample

Go

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

This code creates a pointer to x, changes x's value through the pointer, then prints the updated value.

Execution Table

Step	Action	Variable	Pointer	Value	Output
1	Declare x	x=10	nil	10
2	Create pointer p to x	x=10	p=&x	10
3	Modify value via pointer *p=20	x=20	p=&x	20
4	Print x	x=20	p=&x	20	20

💡 Program ends after printing updated x value 20

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
x	10	10	20	20
p	nil	&x	&x	&x

Key Moments - 3 Insights

Why does changing *p also change x?

Because p points to x's memory address, modifying *p changes the value stored at that address, which is x (see execution_table step 3).

What happens if we print *p before assigning it?

It prints the current value of x since *p dereferences the pointer to x (see execution_table step 2 shows p points to x with value 10).

Why do we use &x to create a pointer?

The & operator gets the memory address of x, which is needed to create a pointer (see execution_table step 2).

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the value of x after *p = 20?

A 10

B 20

C nil

D Pointer address

💡 Hint

Check the 'Variable' column at step 3 in execution_table

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

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the 'Pointer' column in execution_table to see when p=&x

If we change *p = 30 at step 3, what would be printed at step 4?

A 30

B 20

C 10

D Pointer address

💡 Hint

Refer to variable_tracker for x's value after modifying *p

Concept Snapshot

Pointers hold memory addresses of variables.
Use & to get address, * to access value at address.
Changing *pointer changes original variable.
Pass pointers to functions to modify variables.
Pointers help avoid copying large data.

Full Transcript

This visual trace shows how pointers work in Go. We start by declaring a variable x with value 10. Then we create a pointer p that holds x's address using &x. Using *p, we change the value at that address to 20, which updates x. Finally, printing x shows 20. Key points: & gets address, * accesses value at address, changing *p changes x. This helps modify variables directly and pass them efficiently to functions.