Pointer declaration in Go - Step-by-Step Execution

Concept Flow - Pointer declaration

Declare variable

↓

Declare pointer variable

↓

Assign address of variable to pointer

↓

Use pointer to access value

↓

Modify value via pointer

↓

End

This flow shows how to declare a variable, then declare a pointer to it, assign the address, and use the pointer to read or change the value.

Execution Sample

Go

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

Declare an int variable x, declare a pointer p to int, assign p the address of x, print value via pointer, change value via pointer, print x.

Execution Table

Step	Action	Variable	Value	Pointer Value	Output
1	Declare x	x	10	undefined
2	Declare p	p	undefined	nil
3	Assign p = &x	p	undefined	address_of_x
4	Print *p	x	10	address_of_x	10
5	Set *p = 20	x	20	address_of_x
6	Print x	x	20	address_of_x	20

💡 Program ends after printing updated x value 20.

Variable Tracker

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

Key Moments - 2 Insights

Why does *p print 10 at step 4 instead of the address?

Because *p means 'value at the address p points to', so it prints the value of x, which is 10 (see execution_table step 4).

Why does changing *p at step 5 change x's value?

Because p points to x's address, so *p = 20 updates x directly (see execution_table step 5 and variable_tracker for x).

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the value of p?

A nil

B address_of_x

C 10

D undefined

💡 Hint

Check the 'Pointer Value' column at step 3 in execution_table.

At which step does the value of x change from 10 to 20?

A Step 5

B Step 3

C Step 4

D Step 6

💡 Hint

Look at the 'Value' column for x in execution_table between steps 4 and 5.

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

A 20

B 10

C address_of_x

D nil

💡 Hint

Pointer p holds the address of x, see 'Pointer Value' column in execution_table step 4.

Concept Snapshot

Pointer declaration in Go:
var x int = 10       // declare variable
var p *int           // declare pointer to int
p = &x               // assign address of x to p
*p accesses value at p's address
Changing *p changes x's value

Full Transcript

This example shows how to declare a variable x and a pointer p to int in Go. We assign p the address of x using &x. Printing *p shows the value of x. Changing *p changes x's value because p points to x. The execution table traces each step, showing variable and pointer values and outputs. Key moments clarify why *p prints the value, not the address, and how changing *p updates x. The quiz tests understanding of pointer values and when x changes.