5. Pointer Receivers

A receiver type on a method can be a pointer.

Methods with pointer receivers can modify the value to which the receiver points. Since methods often need to modify their receiver, pointer receivers are more common than value receivers. However, methods with pointer receivers don't require that a pointer is used to call the method — the pointer will automatically be derived from the value.

Pointer Receiver

pointer_receiver.go

type car struct {
	color string
}

func (c *car) setColor(color string) {
	c.color = color
}

func main() {
	c := car{
		color: "white",
	}
	c.setColor("blue")
	fmt.Println(c.color)
	// prints "blue"
}

Non-Pointer Receiver

value_receiver.go

type car struct {
	color string
}

func (c car) setColor(color string) {
	c.color = color
}

func main() {
	c := car{
		color: "white",
	}
	c.setColor("blue")
	fmt.Println(c.color)
	// prints "white"
}

What Are Receivers?

A receiver lets you attach a method to a type:

receiver_syntax.go

func (receiverName receiverType) methodName() {
    // method body
}

Pointer Receiver vs Value Receiver

Pointer Receiver (Can Modify)

pointer_example.go

func (c *car) setColor(color string) {
    c.color = color  // Modifies the original
}

• *car = pointer receiver

• Changes the original struct

• Most common when you need to modify the struct

Value Receiver (Cannot Modify)

value_example.go

func (c car) setColor(color string) {
    c.color = color  // Only modifies the copy
}

• car = value receiver

• Receives a copy of the struct

• Changes don't affect the original

Complete Examples

Pointer Receiver Example

pointer_complete.go

type car struct {
    color string
}

func (c *car) setColor(color string) {
    c.color = color
}

func main() {
    c := car{color: "white"}
    c.setColor("blue")
    fmt.Println(c.color)  // "blue" (modified!)
}

Value Receiver Example

value_complete.go

type car struct {
    color string
}

func (c car) setColor(color string) {
    c.color = color  // Only changes the copy
}

func main() {
    c := car{color: "white"}
    c.setColor("blue")
    fmt.Println(c.color)  // "white" (unchanged!)
}

Go's Automatic Pointer Magic

You can call pointer receiver methods on values:

auto_pointer.go

func (c *car) setColor(color string) {
    c.color = color
}

func main() {
    c := car{color: "white"}  // c is a VALUE
    c.setColor("blue")         // Go automatically does (&c).setColor("blue")
    fmt.Println(c.color)       // "blue"
}

Go automatically converts c.setColor() to (&c).setColor() for you.

When to Use Each

1

Use Pointer Receiver

use_pointer.go

func (c *car) setColor(color string) { }

• You need to modify the struct

• The struct is large (avoid copying)

• You want changes to persist

2

Use Value Receiver

use_value.go

func (c car) getColor() string { }

• You're just reading data (not modifying)

• The struct is small

• You want the method to be side-effect free

Real-World Example

user_example.go

type user struct {
    name     string
    age      int
    loggedIn bool
}

// Pointer receiver - modifies user
func (u *user) login() {
    u.loggedIn = true
}

// Pointer receiver - modifies user
func (u *user) updateAge(newAge int) {
    u.age = newAge
}

// Value receiver - just reads data
func (u user) isAdult() bool {
    return u.age >= 18
}

// Value receiver - just reads data
func (u user) getName() string {
    return u.name
}

func main() {
    bob := user{name: "Bob", age: 25, loggedIn: false}
    
    bob.login()          // Modifies bob
    bob.updateAge(26)    // Modifies bob
    
    adult := bob.isAdult()  // Just reads, doesn't modify
    name := bob.getName()   // Just reads, doesn't modify
    
    fmt.Println(bob.loggedIn)  // true
    fmt.Println(bob.age)       // 26
}

Comparison to Regular Functions

Method with Pointer Receiver

method_vs_function_method.go

func (c *car) setColor(color string) {
    c.color = color
}

c.setColor("blue")

Equivalent Function

method_vs_function_func.go

func setColor(c *car, color string) {
    c.color = color
}

setColor(&c, "blue")

Methods are just syntactic sugar — cleaner to write and read.

Common Pattern: Builder Methods

builder.go

type user struct {
    name  string
    email string
    age   int
}

func (u *user) setName(name string) *user {
    u.name = name
    return u
}

func (u *user) setEmail(email string) *user {
    u.email = email
    return u
}

func (u *user) setAge(age int) *user {
    u.age = age
    return u
}

func main() {
    u := &user{}
    u.setName("Alice").setEmail("[e-mail]").setAge(30)
    // Method chaining!
}

Quick Reference

Type	Syntax	Modifies Original?	Use When
Pointer receiver	func (t *Type)	Yes	Need to modify struct
Value receiver	func (t Type)	No	Just reading data

Key Takeaways

• Pointer receiver (*Type) - modifies original, most common

• Value receiver (Type) - works on copy, for read-only operations

• Go auto-converts - can call c.method() even if method expects *c

• Choose based on intent - modify = pointer, read = value

• Methods are cleaner - c.setColor() vs setColor(&c)

Rule of thumb: If the method modifies the receiver, use a pointer receiver.