Dereference Operator in Go: What It Is and How It Works

In Go, the * symbol is the dereference operator used to access the value stored at a pointer's memory address. It lets you read or modify the actual data that the pointer points to, rather than the pointer itself.

How It Works

Think of a pointer as a note that tells you where something is stored in your house, but not the thing itself. The dereference operator * is like using that note to go to the exact spot and see or change the item there.

In Go, when you have a pointer variable, it holds the memory address of another variable. Using *pointer lets you reach into that address and work directly with the value stored there. This is useful because it allows you to change data in one place and have those changes reflected wherever the pointer is used.

Example

This example shows how to declare a pointer, assign it the address of a variable, and then use the dereference operator to read and change the variable's value.

go

package main

import "fmt"

func main() {
    x := 10
    p := &x          // p holds the address of x
    fmt.Println(*p)  // dereference p to get the value of x

    *p = 20          // change the value at the address p points to
    fmt.Println(x)   // x is now updated to 20
}

Output

10
20

When to Use

Use the dereference operator when you want to work directly with the value a pointer points to. This is common when you want to modify a variable inside a function without returning it, or when working with data structures like linked lists or trees.

For example, passing a pointer to a function lets that function change the original variable's value. It also helps save memory by avoiding copying large data structures.

Key Points

• The dereference operator * accesses the value at a pointer's address.
• It allows reading or modifying the original data through the pointer.
• Useful for efficient memory use and modifying variables inside functions.
• Always ensure the pointer is not nil before dereferencing to avoid runtime errors.

Key Takeaways

The dereference operator (*) accesses the value stored at a pointer's address in Go.

It lets you read or change the original variable through its pointer.

Use it to modify variables inside functions without copying data.

Always check pointers are not nil before dereferencing to avoid errors.