Method call behavior in Go - Mini Project: Build & Apply

Method call behavior

📖 Scenario: Imagine you have a simple program that manages a counter. You want to understand how calling methods on a value type and a pointer type affects the data.

🎯 Goal: You will create a Counter struct, add methods to increase the count, and observe how method calls behave differently when using a value receiver versus a pointer receiver.

📋 What You'll Learn

Create a struct called Counter with a field count of type int

Create a method IncrementValue with a value receiver that increases count by 1

Create a method IncrementPointer with a pointer receiver that increases count by 1

Create a main function to test calling both methods on a Counter value and pointer

Print the count after each method call to observe the behavior

💡 Why This Matters

🌍 Real World

Understanding method call behavior is important when working with structs in Go, especially when you want to modify data inside methods or keep data immutable.

💼 Career

Many Go jobs require writing clean and efficient code with structs and methods. Knowing when to use pointer receivers versus value receivers helps avoid bugs and improves performance.

1

Create the Counter struct

Create a struct called Counter with a field count of type int.

Go

// Your code here

Hint

Use the type keyword to define a struct named Counter with one field count of type int.

2

Add methods IncrementValue and IncrementPointer

Add two methods to Counter: IncrementValue with a value receiver that adds 1 to count, and IncrementPointer with a pointer receiver that adds 1 to count.

Go

package main

type Counter struct {
    count int
}

// Your code here

Hint

Define IncrementValue with a value receiver c Counter and increase c.count by 1. Define IncrementPointer with a pointer receiver c *Counter and increase c.count by 1.

3

Create main function and call methods

Create a main function. Inside it, create a variable c of type Counter. Call IncrementValue on c, then call IncrementPointer on the address of c. After each call, print c.count using fmt.Println.

Go

package main

import "fmt"

type Counter struct {
    count int
}

func (c Counter) IncrementValue() {
    c.count++
}

func (c *Counter) IncrementPointer() {
    c.count++
}

func main() {
    // Your code here
}

Hint

Inside main, create c as Counter{}. Call c.IncrementValue(), print c.count, then call c.IncrementPointer() and print c.count again.

4

Run and observe the output

Run the program and observe the output. It should print the value of c.count after each method call. Write a fmt.Println statement to print the final value of c.count after both method calls.

Go

package main

import "fmt"

type Counter struct {
    count int
}

func (c Counter) IncrementValue() {
    c.count++
}

func (c *Counter) IncrementPointer() {
    c.count++
}

func main() {
    c := Counter{}
    c.IncrementValue()
    fmt.Println(c.count)
    c.IncrementPointer()
    fmt.Println(c.count)
    // Your code here
}

Hint

Notice that calling IncrementValue does not change c.count because it works on a copy. Calling IncrementPointer changes c.count because it works on the original.

Practice

1. In Go, what happens when you call a method with a value receiver on a variable?

easy

A. The method can only read but not access the variable's fields.

B. The method works on a copy of the variable, so original data is not changed.

C. The method call causes a compile-time error.

D. The method directly modifies the original variable.

Solution

1. Step 1: Understand value receiver behavior

   Methods with value receivers get a copy of the variable, not the original.

2. Step 2: Effect on original variable

   Since the method works on a copy, changes inside the method do not affect the original variable.

3. Final Answer:

   The method works on a copy of the variable, so original data is not changed. -> Option B

4. Quick Check:

   Value receiver = copy, no original change [OK]

Hint: Value receivers work on copies, so original stays unchanged [OK]

Common Mistakes:

• Thinking value receivers modify original data
• Confusing pointer and value receivers
• Assuming method call causes error

2. Which of the following is the correct syntax to define a method with a pointer receiver in Go?

easy

A. func (p *Person) UpdateName(newName string) {}

B. func (p Person*) UpdateName(newName string) {}

C. func (p Person) *UpdateName(newName string) {}

D. func *Person (p) UpdateName(newName string) {}

Solution

1. Step 1: Recall pointer receiver syntax

   Pointer receivers are declared as (variable *Type) before method name.

2. Step 2: Match correct syntax

   func (p *Person) UpdateName(newName string) {} matches the correct syntax: func (p *Person) MethodName(params) {}.

3. Final Answer:

   func (p *Person) UpdateName(newName string) {} -> Option A

4. Quick Check:

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

Hint: Pointer receiver syntax: (var *Type) before method name [OK]

Common Mistakes:

• Placing * after type name incorrectly
• Using * before method name
• Confusing pointer receiver with pointer return type

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. 6\n7

B. 5\n5

C. 6\n6

D. 5\n6

Solution

1. Step 1: Analyze Increment method call

   Increment has a value receiver, so c.count++ modifies a copy, original c.count remains 5.

2. Step 2: Analyze IncrementPtr method call

   IncrementPtr has a pointer receiver, so c.count++ modifies original c.count, changing it from 5 to 6.

3. Final Answer:

   5\n6 -> Option D

4. Quick Check:

   Value receiver no change, pointer receiver changes original [OK]

Hint: Value receiver copies; pointer receiver modifies original [OK]

Common Mistakes:

• Assuming value receiver changes original
• Confusing method call effects
• Ignoring pointer receiver behavior

4. Identify the error in this Go code snippet:

type Item struct { value int }
func (i Item) SetValue(v int) { i.value = v }
func main() {
  item := Item{value: 10}
  item.SetValue(20)
  fmt.Println(item.value)
}

medium

A. SetValue method uses a value receiver, so item.value is not updated.

B. Missing pointer receiver causes compile error.

C. fmt package is not imported, causing error.

D. SetValue method should return the new value.

Solution

1. Step 1: Check method receiver type

   SetValue uses a value receiver, so it works on a copy of item.

2. Step 2: Effect on original item

   Changes inside SetValue do not affect original item.value, so it remains 10.

3. Final Answer:

   SetValue method uses a value receiver, so item.value is not updated. -> Option A

4. Quick Check:

   Value receiver means no original update [OK]

Hint: Value receiver methods can't update original struct fields [OK]

Common Mistakes:

• Assuming pointer receiver is mandatory for compilation
• Thinking method return needed to update value
• Ignoring import fmt requirement (not shown here)

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

package main
import "fmt"
type Number struct { n int }
func (num Number) Double() Number { num.n *= 2; return num }
func (num *Number) Triple() { num.n *= 3 }
func main() {
  x := Number{n: 2}
  y := x.Double()
  y.Triple()
  fmt.Println(x.n, y.n)
}

hard

A. 4 6

B. 2 6

C. 2 12

D. 4 12

Solution

1. Step 1: Call x.Double()

   Double has a value receiver, so it works on a copy of x, doubles n from 2 to 4, and returns it as y.

2. Step 2: Call y.Triple()

   Triple has a pointer receiver, so it modifies y.n in place, tripling 4 to 12.

3. Step 3: Print values

   x.n remains 2 (unchanged), y.n is 12 after doubling then tripling.

4. Final Answer:

   2 12 -> Option C

5. Quick Check:

   Value receiver returns copy doubled, pointer receiver modifies copy [OK]

Hint: Value receiver returns copy; pointer receiver modifies that copy [OK]

Common Mistakes:

• Assuming x.n changes after Double()
• Confusing which variable is modified by Triple()
• Ignoring return value from Double()