Method call behavior in Go - Step-by-Step Execution

Concept Flow - Method call behavior

Create object

↓

Call method on object

↓

Method receives object or pointer

↓

Method executes code

↓

Return result or modify object

↓

Continue program

This flow shows how a method is called on an object, how the method receives the object or pointer, executes, and returns or modifies the object.

Execution Sample

Go

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

This code creates a Counter object, calls its Increment method which increases count by 1, then prints the count.

Execution Table

Step	Action	Object State (count)	Method Receiver	Output
1	Create Counter c	count=0	N/A	N/A
2	Call c.Increment()	count=0 before call	*Counter (pointer to c)	N/A
3	Inside Increment method	count=1 after increment	*Counter	N/A
4	Return from Increment	count=1	N/A	N/A
5	Print c.count	count=1	N/A	1

💡 Program ends after printing count value 1

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
c.count	0	0	1	1

Key Moments - 2 Insights

Why does the count change after calling Increment even though we pass a pointer?

Because the method receiver is a pointer (*Counter), the method modifies the original object, so count changes as shown in execution_table step 3.

What if the method receiver was not a pointer, would count change?

If the receiver was a value (Counter), the method would work on a copy, so changes inside the method would not affect the original count (not shown here).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of c.count immediately after step 2?

A Undefined

B 1

C 0

D 2

💡 Hint

Check the 'Object State (count)' column at step 2 in the execution_table.

At which step does the count actually increase?

A Step 1

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Object State (count)' column and see when count changes from 0 to 1.

If the Increment method had a value receiver instead of pointer, what would happen to c.count after calling Increment?

A It would remain 0

B It would increase to 1

C It would cause a compile error

D It would become -1

💡 Hint

Recall key_moments explanation about pointer vs value receivers affecting original object.

Concept Snapshot

Method call behavior in Go:
- Methods can have value or pointer receivers.
- Pointer receivers (*Type) modify original object.
- Value receivers (Type) work on copies.
- Call syntax: obj.Method()
- Changes in pointer receiver methods affect original object.

Full Transcript

This example shows how a method call works in Go. We create a Counter object with count 0. When we call the Increment method with a pointer receiver, it increases count by 1 inside the method. The change affects the original object because the method receives a pointer. Finally, printing c.count outputs 1. If the method used a value receiver, the count would not change outside the method. This helps understand how methods can modify objects in Go.

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()