Mastering Pointers in Go: A Complete Beginner-to-Advanced Guide

Go (Golang) is a powerful, statically typed language built for simplicity, performance, and scalability. One of the key features that sets Go apart from many high-level languages is its support for pointers, which allow you to directly reference memory addresses.

In this blog, you’ll learn everything you need to know about pointers in Go — from what they are and why they matter, to how they’re used in real-world applications.

📌 What is a Pointer?

A pointer is a variable that holds the memory address of another variable.

👉 Analogy:

Think of a variable as a house and its value as a person living inside. A pointer is like the house’s address written on a note. You don’t carry the person — you carry the address.

🧪 Basic Pointer Syntax in Go

var x int = 10
var p *int = &x

• x is an int variable.
• &x gives the memory address of x.
• p is a pointer to int (*int) that stores that address.

🔍 Dereferencing

To get the value stored at the pointer address:

fmt.Println(*p) // Output: 10

⚙️ Why Use Pointers?

• 🔁 Avoid copying large values (performance gain).
• 🧠 Modify values inside functions.
• ⚒️ Work with dynamic data structures (like linked lists, trees).
• 🚀 Share state between functions or goroutines.

🧑‍💻 Example: Modify Value via Pointer

func update(val *int) {
    *val = 99
}

func main() {
    num := 50
    update(&num)
    fmt.Println(num) // Output: 99
}

✅ *val = 99 changes the original num since we're working with its memory address.

🆚 Value vs Pointer

🆕 The new() Keyword

ptr := new(int)
*ptr = 77
fmt.Println(*ptr) // Output: 77

• new(int) allocates memory for an int and returns a pointer to it.
• The pointer’s default value is zero.

👤 Pointers with Structs

type User struct {
    Name string
}

func rename(u *User) {
    u.Name = "Alice"
}

func main() {
    user := User{Name: "Bob"}
    rename(&user)
    fmt.Println(user.Name) // Output: Alice
}

✅ Modifications inside the function persist outside because we pass a pointer.

🧠 Common Pitfalls

1. ❌ Dereferencing a nil pointer

var p *int
   fmt.Println(*p) // panic: runtime error: invalid memory address

1. ✅ Always check for nil:

if p != nil {
       fmt.Println(*p)
   }

🔄 Passing by Value vs Pointer (Recap)

🔚 Conclusion

Pointers are a core concept in Go that unlock performance, control, and flexibility. By mastering pointers, you gain a deeper understanding of how data flows and memory works under the hood — critical skills for any serious Go developer.

✨ Remember: With great power (pointers), comes great responsibility (memory safety)!