Common pointer use cases in Go - Mini Project: Build & Apply

Common pointer use cases

📖 Scenario: You are learning how pointers work in Go. Pointers let you directly change values stored in memory. This is useful when you want to update data inside functions or share data efficiently.

🎯 Goal: Build a simple Go program that uses pointers to update a variable's value, swap two numbers, and modify a struct field.

📋 What You'll Learn

Create an integer variable and a pointer to it

Create a function that uses a pointer to update an integer value

Create a function that swaps two integers using pointers

Create a struct and a function that modifies its field using a pointer

💡 Why This Matters

🌍 Real World

Pointers are used in Go to efficiently update data, manage memory, and work with complex data structures like linked lists or trees.

💼 Career

Understanding pointers is important for Go developers working on performance-critical applications, system programming, or backend services.

1

Create an integer variable and a pointer to it

Create an integer variable called num with value 10. Then create a pointer variable called ptr that points to num.

Go

# Create an integer variable called num with value 10
# Create a pointer variable called ptr that points to num

Hint

Use & to get the address of a variable.

2

Create a function to update an integer value using a pointer

Add a function called updateValue that takes a pointer to an integer *int and sets the value it points to 20. Call updateValue in main passing ptr.

Go

package main

import "fmt"

func main() {
    num := 10
    ptr := &num

    // Call updateValue with ptr

}

// Create updateValue function here

Hint

Use *p = 20 to change the value at the pointer.

3

Create a function to swap two integers using pointers

Add a function called swap that takes two pointers to integers *int and swaps the values they point to. In main, create two integers a = 5 and b = 10, then call swap passing pointers to a and b.

Go

package main

import "fmt"

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

func main() {
    num := 10
    ptr := &num

    updateValue(ptr)

    // Create variables a and b
    // Call swap with pointers to a and b
}

// Create swap function here

Hint

Use a temporary variable to swap values pointed by the pointers.

4

Create a struct and modify its field using a pointer

Define a struct type called Person with a field age of type int. Create a function called increaseAge that takes a pointer to Person and increases the age by 1. In main, create a Person variable with age = 30, then call increaseAge passing its pointer. Finally, print the updated age using fmt.Println.

Go

package main

import "fmt"

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

func swap(x *int, y *int) {
    temp := *x
    *x = *y
    *y = temp
}

func main() {
    num := 10
    ptr := &num

    updateValue(ptr)

    a := 5
    b := 10
    swap(&a, &b)

    // Create a Person variable with age 30
    // Call increaseAge with pointer to Person
    // Print the updated age
}

// Define Person struct
// Define increaseAge function

Hint

Use p.age += 1 to increase the age field through the pointer.

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