Common pointer use cases in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of pointer dereference and modification

What is the output of this Go program?

Go

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

A 20

B 10

C Compilation error

D Runtime panic

💡 Hint

Remember that modifying the value through a pointer changes the original variable.

The pointer p points to x. Changing *p changes x's value to 20. So printing x outputs 20.

❓ Predict Output

intermediate

Pointer nil check and output

What will this Go program print?

Go

package main
import "fmt"
func main() {
    var p *int
    if p == nil {
        fmt.Println("Pointer is nil")
    } else {
        fmt.Println("Pointer is not nil")
    }
}

A Runtime panic

B Pointer is nil

C Compilation error

D Pointer is not nil

💡 Hint

Uninitialized pointers have a zero value of nil.

The pointer p is declared but not assigned, so it is nil. The if condition is true, printing "Pointer is nil".

❓ Predict Output

advanced

Effect of pointer on function argument

What is the output of this Go program?

Go

package main
import "fmt"
func increment(n *int) {
    *n = *n + 1
}
func main() {
    x := 5
    increment(&x)
    fmt.Println(x)
}

A 5

B Compilation error

C 6

D Runtime panic

💡 Hint

Passing a pointer allows the function to modify the original variable.

The function increment receives a pointer to x and increases the value it points to by 1. So x becomes 6.

❓ Predict Output

advanced

Pointer to struct field modification

What will this Go program print?

Go

package main
import "fmt"
type Person struct {
    age int
}
func main() {
    p := Person{age: 30}
    ptr := &p.age
    *ptr = 40
    fmt.Println(p.age)
}

A 40

B Runtime panic

C Compilation error

D 30

💡 Hint

Pointers can point to struct fields and modify them directly.

ptr points to p.age. Changing *ptr changes p.age to 40. So printing p.age outputs 40.

🧠 Conceptual

expert

Pointer zero value and memory safety

Which statement about pointers in Go is TRUE?

A Pointers in Go can be used to access private fields of other packages.

B A pointer variable always points to a valid memory address after declaration.

C Go allows pointer arithmetic similar to C.

D Dereferencing a nil pointer causes a runtime panic.

💡 Hint

Think about what happens if you try to use a pointer that has not been assigned.

In Go, a pointer declared but not assigned is nil. Dereferencing nil causes a runtime panic. Go does not support pointer arithmetic and enforces package privacy.

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