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

#go #softwareengineering #programming

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

Feature	Value (Copy)	Pointer (Reference)
Memory usage	More (copies value)	Less (copies address)
Modify original?	❌ No	✅ Yes
Performance	Slower with large data	Faster

🆕 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

❌ Dereferencing a nil pointer

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

✅ Always check for nil:

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

🔄 Passing by Value vs Pointer (Recap)

Case	Use Pointer?
Modify original data	✅ Yes
Pass large structs	✅ Yes
Read-only small values	❌ No

🔚 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.