Receiver types in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of method with pointer receiver

What is the output of this Go program?

Go

package main
import "fmt"
type Counter struct {
    count int
}
func (c *Counter) Increment() {
    c.count++
}
func main() {
    c := Counter{count: 5}
    c.Increment()
    fmt.Println(c.count)
}

A 5

B 6

C 0

D Compilation error

💡 Hint

Think about how pointer receivers modify the original struct.

The method Increment has a pointer receiver, so it modifies the original Counter instance. Starting from 5, Increment adds 1, so the output is 6.

❓ Predict Output

intermediate

Value receiver method effect

What will be printed by this Go program?

Go

package main
import "fmt"
type Number struct {
    value int
}
func (n Number) Double() {
    n.value *= 2
}
func main() {
    num := Number{value: 10}
    num.Double()
    fmt.Println(num.value)
}

A Compilation error

B 20

C 0

D 10

💡 Hint

Consider if the method changes the original struct or a copy.

The Double method has a value receiver, so it works on a copy of num. The original num.value remains 10.

🔧 Debug

advanced

Why does this method not modify the struct?

Given this code, why does the method not change the struct's field?

Go

package main
import "fmt"
type Item struct {
    name string
}
func (i Item) Rename(newName string) {
    i.name = newName
}
func main() {
    it := Item{name: "Book"}
    it.Rename("Notebook")
    fmt.Println(it.name)
}

A Because Rename uses a value receiver, it modifies a copy, not the original struct.

B Because the field name is unexported and cannot be changed.

C Because the method Rename is not called properly.

D Because the struct Item is immutable in Go.

💡 Hint

Think about how value receivers work in Go methods.

Methods with value receivers get a copy of the struct. Changing fields on the copy does not affect the original struct.

❓ Predict Output

advanced

Output with mixed receiver types

What is the output of this Go program?

Go

package main
import "fmt"
type Box struct {
    size int
}
func (b Box) Grow() {
    b.size += 10
}
func (b *Box) Expand() {
    b.size += 20
}
func main() {
    b := Box{size: 5}
    b.Grow()
    b.Expand()
    fmt.Println(b.size)
}

A 25

B 35

C 15

D Compilation error

💡 Hint

Remember which methods modify the original struct and which do not.

Grow has a value receiver and does not change the original size (still 5). Expand has a pointer receiver and adds 20, so final size is 25.

🧠 Conceptual

expert

Choosing receiver types for methods

Which statement about receiver types in Go is correct?

A Value receivers always improve performance by avoiding pointers.

B Value receivers are required to modify the original struct fields.

C Pointer receivers allow methods to modify the original struct and avoid copying large structs.

D Pointer receivers cannot be used with interface types.

💡 Hint

Think about when you want to change the original data and efficiency.

Pointer receivers let methods change the original struct and avoid copying large structs. Value receivers work on copies and cannot modify the original.

Practice

1. What is the main difference between a value receiver and a pointer receiver in Go methods?

easy

A. Value receivers are faster than pointer receivers in all cases.

B. Value receivers can only read data; pointer receivers can only write data.

C. Pointer receivers create a new copy of the data each time.

D. Value receivers get a copy of the data; pointer receivers get the original data to modify.

Solution

1. Step 1: Understand receiver types

   Value receivers receive a copy of the original data, so changes inside the method do not affect the original.

2. Step 2: Pointer receivers behavior

   Pointer receivers receive the address of the original data, allowing methods to modify the original value.

3. Final Answer:

   Value receivers get a copy of the data; pointer receivers get the original data to modify. -> Option D

4. Quick Check:

   Receiver type = copy vs original [OK]

Hint: Pointer receivers allow modifying original data, value receivers do not [OK]

Common Mistakes:

• Thinking value receivers modify original data
• Believing pointer receivers create copies
• Assuming pointer receivers are always slower

2. Which of the following is the correct syntax to define a method with a pointer receiver for a struct Person?

easy

A. func (p Person) Greet() string { return "Hi" }

B. func (p *Person) Greet() string { return "Hi" }

C. func Greet(p *Person) string { return "Hi" }

D. func (p Person*) Greet() string { return "Hi" }

Solution

1. Step 1: Identify pointer receiver syntax

   Pointer receivers use an asterisk before the type in the receiver: (p *Person).

2. Step 2: Check method declaration format

   The method must be declared with receiver in parentheses before the method name.

3. Final Answer:

   func (p *Person) Greet() string { return "Hi" } -> Option B

4. Quick Check:

   Pointer receiver syntax = (p *Type) [OK]

Hint: Pointer receiver syntax uses * before type inside parentheses [OK]

Common Mistakes:

• Missing parentheses around receiver
• Placing * after variable name instead of type
• Defining method without receiver

3. What will be the output of this Go program?

package main
import "fmt"
type Counter struct { count int }
func (c Counter) Increment() { c.count++ }
func (c *Counter) IncrementPtr() { c.count++ }
func main() {
  c := Counter{count: 5}
  c.Increment()
  fmt.Println(c.count)
  c.IncrementPtr()
  fmt.Println(c.count)
}

medium

A. 5
6

B. 5
5

C. 6
6

D. 6
7

Solution

1. Step 1: Analyze Increment method with value receiver

   Increment uses a value receiver, so it works on a copy. The original count remains 5 after calling Increment.

2. Step 2: Analyze IncrementPtr method with pointer receiver

   IncrementPtr uses a pointer receiver, so it modifies the original count from 5 to 6.

3. Final Answer:

   5 6 -> Option A

4. Quick Check:

   Value receiver no change, pointer receiver changes [OK]

Hint: Value receiver copies data; pointer receiver changes original [OK]

Common Mistakes:

• Assuming value receiver changes original
• Confusing method calls with pointer vs value receivers
• Expecting both increments to change count

4. Identify the error in this Go code snippet:

type Rectangle struct { width, height int }
func (r Rectangle) Scale(factor int) {
  r.width = r.width * factor
  r.height = r.height * factor
}
func main() {
  rect := Rectangle{2, 3}
  rect.Scale(2)
  fmt.Println(rect.width, rect.height)
}

medium

A. The struct fields width and height must be pointers.

B. Scale method must return a new Rectangle instead of modifying fields.

C. Scale method should have a pointer receiver to modify Rectangle fields.

D. The Scale method should be defined outside the Rectangle type.

Solution

1. Step 1: Check receiver type in Scale method

   Scale uses a value receiver, so it works on a copy and does not modify the original Rectangle.

2. Step 2: Fix receiver to pointer to modify original

   Changing receiver to pointer (r *Rectangle) allows Scale to modify the original struct fields.

3. Final Answer:

   Scale method should have a pointer receiver to modify Rectangle fields. -> Option C

4. Quick Check:

   Modify struct fields = pointer receiver needed [OK]

Hint: Use pointer receiver to change struct fields inside methods [OK]

Common Mistakes:

• Using value receiver expecting changes to persist
• Trying to make struct fields pointers unnecessarily
• Thinking methods must be outside struct

5. You want to create a Go method Reset for a struct Timer that sets its seconds field to zero. Which receiver type should you use and why?

hard

A. Use a pointer receiver because you need to modify the original Timer's seconds field.

B. Use a value receiver because it is simpler and does not modify the original.

C. Use a value receiver and return a new Timer with seconds zeroed.

D. Use a pointer receiver but do not modify any fields inside the method.

Solution

1. Step 1: Understand the goal of Reset method

   Reset must change the Timer's seconds field to zero, modifying the original struct.

2. Step 2: Choose receiver type to allow modification

   Pointer receiver is needed to modify the original Timer instance inside the method.

3. Final Answer:

   Use a pointer receiver because you need to modify the original Timer's seconds field. -> Option A

4. Quick Check:

   Modify original struct = pointer receiver [OK]

Hint: Modify original struct? Use pointer receiver [OK]

Common Mistakes:

• Using value receiver expecting original to change
• Returning new struct instead of modifying original
• Using pointer receiver but not modifying fields