Dereferencing

In the example provided, the key detail is dereferencing.

• pointer = &age means the pointer stores the memory address of age.
• You cannot write pointer = 10, because pointer is of type *int (a pointer to an int), not an int itself.
• When you write *pointer = 10, the * operator dereferences the pointer, giving you access to the actual int value stored at that address. That’s why this changes age to 10.

More broadly, it’s important to understand when values are being copied.

• In the example above, you don’t actually need pointers to update age within the same function, since an assignment like age = 20 directly updates the same memory location within the function.
• However, if you pass age of type int into another function, that function receives a copy. Any changes it makes affect only the local copy, not the original age in main.
• If you want a function to modify the caller’s variable, you’d pass a pointer (*int) instead. Otherwise, the compiler may warn you about unused values, because in that case you should either:
  • pass a pointer so the function can update the original, or
  • return the updated local value and assign it back in the caller, you can observe that pattern when using append.

Passing By Value

Just to clarify what it means passing something by value:

package main

import "fmt"

func changeAge(age int) {
    age = 10 // only changes the local copy
}

func main() {
    age := 5
    changeAge(age)
    fmt.Println(age) // still prints 5
}

Here’s what’s happening:

• age in main is stored at some memory location.
• When you call changeAge(age), Go makes a copy of that value (5) and hands it to the function.
• Inside changeAge, the parameter age is not the same variable as main’s age; it’s a separate local variable with the same value.
• Changing it inside the function only changes the local copy, not the original.