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.

Practice

1. What does a pointer in Go store?

easy

A. The memory address of a variable

B. The value of a variable

C. The type of a variable

D. The size of a variable

Solution

1. Step 1: Understand what a pointer represents

   A pointer holds the location in memory where a variable is stored, not the value itself.

2. Step 2: Differentiate pointer from value

   The value is stored at the address the pointer points to, not inside the pointer variable.

3. Final Answer:

   The memory address of a variable -> Option A

4. Quick Check:

   Pointers store addresses = B [OK]

Hint: Pointers hold addresses, not values directly [OK]

Common Mistakes:

• Confusing pointer with the actual value
• Thinking pointer stores variable type
• Assuming pointer stores variable size

2. Which of the following is the correct way to declare a pointer to an int in Go?

easy

A. var p int*

B. var p &int

C. var p *int

D. var *p int

Solution

1. Step 1: Recall Go pointer syntax

   In Go, a pointer type is written as *Type, so a pointer to int is *int.

2. Step 2: Check variable declaration format

   The variable name comes after var, then the type. So correct is var p *int.

3. Final Answer:

   var p *int -> Option C

4. Quick Check:

   Pointer syntax is var name *Type = D [OK]

Hint: Pointer type uses * before type, not after variable [OK]

Common Mistakes:

• Placing * after variable name
• Using & instead of * for pointer type
• Incorrect order of * and variable name

3. What is the output of this Go code?

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

medium

A. 10

B. Memory address of x

C. Compilation error

D. 20

Solution

1. Step 1: Understand pointer assignment

   p points to x's address. Changing *p changes the value at x's address.

2. Step 2: Trace value change

   *p = 20 sets x to 20. So printing x outputs 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   Pointer changes original value = 20 [OK]

Hint: Changing *p changes original variable value [OK]

Common Mistakes:

• Thinking x remains 10 after *p = 20
• Printing pointer address instead of value
• Assuming compilation error due to pointer

4. Identify the error in this Go code snippet:

func updateValue(p *int) {
    *p = 100
}

func main() {
    var p *int
    updateValue(p)
}

medium

A. Syntax error in function declaration

B. p is nil and dereferenced causing runtime panic

C. updateValue should return an int

D. No error, code runs fine

Solution

1. Step 1: Check pointer initialization

   p is declared but not assigned an address, so it is nil.

2. Step 2: Analyze dereferencing nil pointer

   updateValue dereferences *p, causing a runtime panic because p is nil.

3. Final Answer:

   p is nil and dereferenced causing runtime panic -> Option B

4. Quick Check:

   Dereferencing nil pointer causes panic = A [OK]

Hint: Never dereference nil pointers without initialization [OK]

Common Mistakes:

• Assuming nil pointer is safe to dereference
• Thinking function must return a value
• Ignoring runtime panic possibility

5. Given this Go code, what will be the output?

func swap(a, b *int) {
    *a, *b = *b, *a
}

func main() {
    x, y := 5, 10
    swap(&x, &y)
    fmt.Println(x, y)
}

hard

A. 10 5

B. 5 10

C. Memory addresses of x and y

D. Compilation error due to swap syntax

Solution

1. Step 1: Understand swap function with pointers

   swap receives pointers to x and y, then swaps the values they point to.

2. Step 2: Trace swap effect on variables

   After swap, x becomes 10 and y becomes 5.

3. Final Answer:

   10 5 -> Option A

4. Quick Check:

   Pointer swap changes original values = 10 5 [OK]

Hint: Swap values by swapping *a and *b via pointers [OK]

Common Mistakes:

• Expecting original values unchanged
• Printing pointer addresses instead of values
• Thinking swap function syntax is invalid