Skip to Content
Go Realm v1 is released 🎉
TopicsPointer 📌

Go Pointers

āĻĒāϝāĻŧ⧇āĻ¨ā§āϟāĻžāϰ āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āĻ­ā§āϝāĻžāϰāĻŋāϝāĻŧ⧇āĻŦāϞ āϝāĻž āĻ…āĻ¨ā§āϝ āĻāĻ•āϟāĻŋ āĻ­ā§āϝāĻžāϰāĻŋāϝāĻŧ⧇āĻŦāϞ⧇āϰ āĻŽā§‡āĻŽā§‹āϰāĻŋ āĻ…ā§āϝāĻžāĻĄā§āϰ⧇āϏ āϧāϰ⧇ āϰāĻžāϖ⧇āĨ¤ āϏāĻšāϜ āĻ­āĻžāώāĻžāϝāĻŧ: āĻĒāϝāĻŧ⧇āĻ¨ā§āϟāĻžāϰ āĻ­ā§āϝāĻžāϞ⧁ āύāĻŋāĻœā§‡ āύāĻž āϰ⧇āϖ⧇ āĻ­ā§āϝāĻžāϞ⧁āϟāĻŋ āϕ⧋āĻĨāĻžāϝāĻŧ āφāϛ⧇ āϏ⧇āϟāĻž āϜāĻžāύ⧇āĨ¤

🏠 āĻ…ā§āϝāĻžāύāĻžāϞāϜāĻŋ: āĻ­ā§āϝāĻžāϰāĻŋāϝāĻŧ⧇āĻŦāϞ āĻšāϞ⧋ āĻŦāĻžāĻĄāĻŧāĻŋ, āĻĒāϝāĻŧ⧇āĻ¨ā§āϟāĻžāϰ āĻšāϞ⧋ āϏ⧇āχ āĻŦāĻžāĻĄāĻŧāĻŋāϰ āĻ āĻŋāĻ•āĻžāύāĻž.


ā§§. Core Operators 📌

OperatorāύāĻžāĻŽāĻ•āĻžāϜāωāĻĻāĻžāĻšāϰāĻŖ
&Address-ofāĻ­ā§āϝāĻžāϰāĻŋāϝāĻŧ⧇āĻŦāϞ⧇āϰ āĻŽā§‡āĻŽā§‹āϰāĻŋ āĻ…ā§āϝāĻžāĻĄā§āϰ⧇āϏ āĻŦ⧇āϰ āĻ•āϰ⧇ptr := &x
*DereferenceāĻĒāϝāĻŧ⧇āĻ¨ā§āϟāĻžāϰ⧇āϰ āĻ…ā§āϝāĻžāĻĄā§āϰ⧇āϏ⧇ āĻĨāĻžāĻ•āĻž āĻ­ā§āϝāĻžāϞ⧁ āĻĒāĻĄāĻŧ⧇/āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻ•āϰ⧇fmt.Println(*ptr)
*TPointer typeT āϟāĻžāχāĻĒ⧇āϰ āĻĒāϝāĻŧ⧇āĻ¨ā§āϟāĻžāϰ āĻĄāĻŋāĻ•ā§āϞ⧇āϝāĻŧāĻžāϰ āĻ•āϰ⧇var p *int
x := 42 ptr := &x // ptr = x-āĻāϰ āĻŽā§‡āĻŽā§‹āϰāĻŋ āĻ…ā§āϝāĻžāĻĄā§āϰ⧇āϏ (āϝ⧇āĻŽāύ 0xc000014070) fmt.Println(x) // 42 — āϏāϰāĻžāϏāϰāĻŋ āĻ­ā§āϝāĻžāϞ⧁ fmt.Println(&x) // 0xc... — x-āĻāϰ āĻ…ā§āϝāĻžāĻĄā§āϰ⧇āϏ fmt.Println(ptr) // 0xc... — ptr-āĻ āĻĨāĻžāĻ•āĻž āĻ…ā§āϝāĻžāĻĄā§āϰ⧇āϏ (same) fmt.Println(*ptr) // 42 — ptr-āĻāϰ āĻ…ā§āϝāĻžāĻĄā§āϰ⧇āϏ⧇ āϝāĻž āφāϛ⧇ *ptr = 100 // x-āĻāϰ āĻ­ā§āϝāĻžāϞ⧁ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻ•āϰāĻž āĻšāϞ⧋ fmt.Println(x) // 100 ✅

⧍. āϕ⧇āύ āĻĒāϝāĻŧ⧇āĻ¨ā§āϟāĻžāϰ āĻĻāϰāĻ•āĻžāϰ?

āĻ•āĻžāϰāĻŖāĻŦā§āϝāĻžāĻ–ā§āϝāĻž
āĻĢāĻžāĻ‚āĻļāύ⧇āϰ āϭ⧇āϤāϰ āĻĨ⧇āϕ⧇ original āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύGo-āϤ⧇ āϏāĻŦ argument copy āĻšāĻŋāϏ⧇āĻŦ⧇ āϝāĻžāϝāĻŧ; pointer āĻĻāĻŋāϞ⧇ original āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āϏāĻŽā§āĻ­āĻŦ
āĻŦāĻĄāĻŧ struct-āĻāϰ copy āĻāĻĄāĻŧāĻžāύ⧋Pointer āĻĒāĻžāϏ āĻ•āϰāϞ⧇ āĻĒ⧁āϰ⧋ struct copy āĻšāϝāĻŧ āύāĻž — performance āĻ­āĻžāϞ⧋
Optional value āĻĒā§āϰāĻ•āĻžāĻļ āĻ•āϰāĻžnil āĻĻāĻŋāϝāĻŧ⧇ “āϕ⧋āύ⧋ āĻ­ā§āϝāĻžāϞ⧁ āύ⧇āĻ‡â€ āĻŦā§‹āĻāĻžāύ⧋ āϝāĻžāϝāĻŧ
// ❌ Copy āĻšāϝāĻŧ — original āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻšāϝāĻŧ āύāĻž func doubleWrong(n int) { n = n * 2 } // ✅ Pointer — original āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻšāϝāĻŧ func double(n *int) { *n = *n * 2 } func main() { x := 5 doubleWrong(x) fmt.Println(x) // 5 — āĻ…āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāĻŋāϤ double(&x) fmt.Println(x) // 10 ✅ }

ā§Š. Pointer āĻāĻŦāĻ‚ Struct (Production Usage)

type User struct { Name string Email string } // ❌ Value — struct-āĻāϰ copy āĻĒāĻžāϏ āĻšāϝāĻŧ func greetValue(u User) { u.Name = "Changed" // original-āĻ āϕ⧋āύ⧋ āĻĒā§āϰāĻ­āĻžāĻŦ āύ⧇āχ } // ✅ Pointer — original struct āĻĒāĻžāϏ āĻšāϝāĻŧ func greetPointer(u *User) { u.Name = "Changed" // original āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻšāϝāĻŧ } func main() { u := User{Name: "Rahim", Email: "rahim@email.com"} greetValue(u) fmt.Println(u.Name) // "Rahim" — āĻ…āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāĻŋāϤ greetPointer(&u) fmt.Println(u.Name) // "Changed" ✅ }

💡 Note: Struct field access-āĻ Go āĻ¸ā§āĻŦāϝāĻŧāĻ‚āĻ•ā§āϰāĻŋāϝāĻŧāĻ­āĻžāĻŦ⧇ pointer dereference āĻ•āϰ⧇āĨ¤ āϤāĻžāχ (*u).Name āύāĻž āϞāĻŋāϖ⧇ āϏāϰāĻžāϏāϰāĻŋ u.Name āϞ⧇āĻ–āĻž āϝāĻžāϝāĻŧāĨ¤


ā§Ē. nil Pointer — āϏāĻŦāĻšā§‡āϝāĻŧ⧇ Common Bug âš ī¸

Pointer declare āĻ•āϰāϞ⧇ āĻ•āĻŋāĻ¨ā§āϤ⧁ initialize āύāĻž āĻ•āϰāϞ⧇ āĻāϰ default value āĻšāϝāĻŧ nil.

var ptr *int // nil — āϕ⧋āύ⧋ āĻ…ā§āϝāĻžāĻĄā§āϰ⧇āϏ āύ⧇āχ fmt.Println(ptr) // <nil> fmt.Println(*ptr) // đŸ’Ĩ panic: nil pointer dereference

āϏāĻŽāĻžāϧāĻžāύ — āϏāĻŦāϏāĻŽāϝāĻŧ nil check āĻ•āϰ⧁āύ:

func printValue(ptr *int) { if ptr == nil { fmt.Println("āϕ⧋āύ⧋ āĻ­ā§āϝāĻžāϞ⧁ āύ⧇āχ") return } fmt.Println(*ptr) }

new() āĻĻāĻŋāϝāĻŧ⧇ initialized pointer āϤ⧈āϰāĻŋ:

ptr := new(int) // *int āϤ⧈āϰāĻŋ, zero value (0) āĻĻāĻŋāϝāĻŧ⧇ initialize *ptr = 42 fmt.Println(*ptr) // 42

ā§Ģ. Value vs Pointer — āϕ⧋āύāϟāĻž āĻ•āĻ–āύ? đŸ”Ĩ

āĻĒāϰāĻŋāĻ¸ā§āĻĨāĻŋāϤāĻŋāĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧁āύ
āϛ⧋āϟ āĻĄā§‡āϟāĻž, āĻļ⧁āϧ⧁ read āĻ•āϰāĻŦ⧇āύValue
āĻĢāĻžāĻ‚āĻļāύ⧇ original āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇Pointer
āĻŦāĻĄāĻŧ struct āĻĒāĻžāϏ āĻ•āϰāϛ⧇āύPointer
”āĻ­ā§āϝāĻžāϞ⧁ āύ⧇āĻ‡â€ āĻŦā§‹āĻāĻžāϤ⧇ āĻšāĻŦ⧇ (optional)Pointer (nil)
sync.Mutex āĻŦāĻž non-copyable typePointer (āĻŦāĻžāĻ§ā§āϝāϤāĻžāĻŽā§‚āϞāĻ•)
Slice, Map, Channel āĻĒāĻžāϏ āĻ•āϰāϛ⧇āύValue (āĻāϗ⧁āϞ⧋ āύāĻŋāĻœā§‡āχ reference type)

ā§Ŧ. Go āϏāĻŦāϏāĻŽāϝāĻŧ Pass by Value (Most Asked Interview Topic) đŸ”Ĩ

āĻāϟāĻŋ Go-āϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦ⧇āĻļāĻŋ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰāĻž interview āĻĒā§āϰāĻļā§āύāϗ⧁āϞ⧋āϰ āĻāĻ•āϟāĻŋāĨ¤

Go-āϤ⧇ āĻĢāĻžāĻ‚āĻļāύ⧇ argument āĻĒāĻžāϏ āĻ•āϰāĻžāϰ āϏāĻŽāϝāĻŧ āϏāĻŦāϏāĻŽāϝāĻŧ āĻāĻ•āϟāĻŋ copy āϤ⧈āϰāĻŋ āĻšāϝāĻŧāĨ¤ Pointer āĻĒāĻžāϏ āĻ•āϰāϞ⧇āĻ“ copy āĻšāϝāĻŧ — āϤāĻŦ⧇ āϏ⧇āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ address-āĻāϰ copy āĻšāϝāĻŧāĨ¤

func changeValue(n int) { n = 99 // int-āĻāϰ copy, original āĻ…āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāĻŋāϤ } func changePointer(n *int) { *n = 99 // address-āĻāϰ copy, āĻ•āĻŋāĻ¨ā§āϤ⧁ āϏ⧇āχ address-āĻ āĻ—āĻŋāϝāĻŧ⧇ original āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻ•āϰāĻž āĻšāϝāĻŧ } func main() { x := 10 changeValue(x) fmt.Println(x) // 10 — āĻ…āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāĻŋāϤ changePointer(&x) fmt.Println(x) // 99 ✅ — original āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāĻŋāϤ }
āϕ⧀ āĻĒāĻžāϏ āĻšāϝāĻŧāĻ•āĻĒāĻŋ āĻšāϝāĻŧOriginal āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻšāϝāĻŧ?
int, string, struct (value)āĻĒ⧁āϰ⧋ āĻ­ā§āϝāĻžāϞ⧁āϰ āĻ•āĻĒāĻŋ❌ āύāĻž
*int, *struct (pointer)address-āĻāϰ āĻ•āĻĒāĻŋ (ā§Ē/ā§Ž āĻŦāĻžāχāϟ)✅ āĻšā§āϝāĻžāρ (dereference āĻ•āϰāϞ⧇)

💡 āĻŽā§‚āϞ āĻ•āĻĨāĻž: Pointer āĻĒāĻžāϏ āĻ•āϰāĻž āĻŽāĻžāύ⧇ “pass by reference” āύāϝāĻŧāĨ¤ Go-āϤ⧇ reference āύ⧇āχāĨ¤ Pointer āĻšāϞ⧋ address-āĻāϰ value — āϏ⧇āϟāĻžāĻ“ copy āĻšāĻŋāϏ⧇āĻŦ⧇āχ āϝāĻžāϝāĻŧāĨ¤


ā§­. Pointer vs Reference Type (Interview Critical)

Go-āϤ⧇ āĻ•āĻŋāϛ⧁ built-in type āφāϛ⧇ āϝ⧇āϗ⧁āϞ⧋ āχāϤāĻŋāĻŽāĻ§ā§āϝ⧇ reference-āĻāϰ āĻŽāϤ⧋ āφāϚāϰāĻŖ āĻ•āϰ⧇:

TypePointer āĻĻāϰāĻ•āĻžāϰ?āĻ•āĻžāϰāĻŖ
int, string, bool, struct✅ āĻĻāϰāĻ•āĻžāϰ āĻšāϞ⧇Value type — copy āĻšāϝāĻŧ
slice❌ āϏāĻžāϧāĻžāϰāĻŖāϤ āύāĻžInternal pointer āφāϛ⧇
map❌ āύāĻžReference type
channel❌ āύāĻžReference type
interface❌ āύāĻžReference type
// Map-āĻ pointer āĻĻāϰāĻ•āĻžāϰ āύ⧇āχ — āĻĢāĻžāĻ‚āĻļāύ⧇ āĻĒāĻžāϏ āĻ•āϰāϞ⧇āĻ“ original update āĻšāϝāĻŧ func addUser(m map[string]int, name string) { m[name] = 1 // ✅ original map-āĻ update āĻšāϝāĻŧ }

ā§Ž. Common Mistakes âš ī¸

āϭ⧁āϞāϏāĻŽāĻ¸ā§āϝāĻžāϏāĻŽāĻžāϧāĻžāύ
nil pointer dereferenceruntime panicāĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āφāϗ⧇ if ptr != nil āĻšā§‡āĻ• āĻ•āϰ⧁āύ
Loop variable pointerāϏāĻŦ pointer āĻāĻ•āχ āĻļ⧇āώ āĻ­ā§āϝāĻžāϞ⧁ āĻĻ⧇āĻ–āĻžāϝāĻŧloop-āĻāϰ āϭ⧇āϤāϰ⧇ āφāϞāĻžāĻĻāĻž āĻ­ā§āϝāĻžāϰāĻŋāϝāĻŧ⧇āĻŦāϞ āϤ⧈āϰāĻŋ āĻ•āϰ⧁āύ
Slice/Map-āĻ āĻ…āĻ•āĻžāϰāϪ⧇ pointerunnecessary complexityāĻāϰāĻž āύāĻŋāĻœā§‡āχ reference, pointer āϞāĻžāϗ⧇ āύāĻž
new() āĻ“ &{} confusion—āĻĻ⧁āĻŸā§‹āχ āĻ•āĻžāϜ āĻ•āϰ⧇, &Struct{} āĻŦ⧇āĻļāĻŋ idiomatic
// ❌ Classic loop pointer bug ptrs := make([]*int, 3) for i := 0; i < 3; i++ { ptrs[i] = &i // āϏāĻŦ pointer āĻļ⧇āώ⧇ i=3 āĻĻ⧇āĻ–āĻžāĻŦ⧇! } // ✅ āϏāĻŽāĻžāϧāĻžāύ — local copy āϤ⧈āϰāĻŋ āĻ•āϰ⧁āύ for i := 0; i < 3; i++ { v := i ptrs[i] = &v }

⧝. Interview Cheat Sheet

Q: āĻĒāϝāĻŧ⧇āĻ¨ā§āϟāĻžāϰ āϕ⧀ āĻāĻŦāĻ‚ āϕ⧇āύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧ?

āĻĒāϝāĻŧ⧇āĻ¨ā§āϟāĻžāϰ āĻāĻ•āϟāĻŋ āĻ­ā§āϝāĻžāϰāĻŋāϝāĻŧ⧇āĻŦāϞ⧇āϰ āĻŽā§‡āĻŽā§‹āϰāĻŋ āĻ…ā§āϝāĻžāĻĄā§āϰ⧇āϏ āϧāϰ⧇ āϰāĻžāϖ⧇āĨ¤ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšāϝāĻŧ: original value āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻ•āϰāϤ⧇, āĻŦāĻĄāĻŧ struct copy āĻāĻĄāĻŧāĻžāϤ⧇ āĻāĻŦāĻ‚ optional value āĻĒā§āϰāĻ•āĻžāĻļ āĻ•āϰāϤ⧇āĨ¤

Q: & āĻāĻŦāĻ‚ *-āĻāϰ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āϕ⧀?

& āĻĻāĻŋāϝāĻŧ⧇ āĻ­ā§āϝāĻžāϰāĻŋāϝāĻŧ⧇āĻŦāϞ⧇āϰ āĻ…ā§āϝāĻžāĻĄā§āϰ⧇āϏ āύ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤ * āĻĻāĻŋāϝāĻŧ⧇ āĻĒāϝāĻŧ⧇āĻ¨ā§āϟāĻžāϰ⧇āϰ āĻ…ā§āϝāĻžāĻĄā§āϰ⧇āϏ⧇ āĻĨāĻžāĻ•āĻž āĻ­ā§āϝāĻžāϞ⧁ access āĻ•āϰāĻž āĻšāϝāĻŧ (dereference)āĨ¤

Q: Pointer-āĻāϰ zero value āϕ⧀?

nil — āĻŽāĻžāύ⧇ āĻāϟāĻŋ āϕ⧋āύ⧋ āĻŽā§‡āĻŽā§‹āϰāĻŋ āĻ…ā§āϝāĻžāĻĄā§āϰ⧇āϏ point āĻ•āϰāϛ⧇ āύāĻžāĨ¤

Q: Slice āĻŦāĻž Map-āĻ āĻ•āĻŋ Pointer āĻĻāϰāĻ•āĻžāϰ?

āϏāĻžāϧāĻžāϰāĻŖāϤ āύāĻžāĨ¤ Slice āĻ“ Map āύāĻŋāĻœā§‡āχ internally reference type — āĻĢāĻžāĻ‚āĻļāύ⧇ āĻĒāĻžāϏ āĻ•āϰāϞ⧇ original-āχ āĻ•āĻžāϜ āĻšāϝāĻŧāĨ¤

Q: new(T) āĻāĻŦāĻ‚ &T{}-āĻāϰ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ? 📌

āĻĻ⧁āĻŸā§‹āχ *T return āĻ•āϰ⧇āĨ¤ new(T) zero value āĻĻāĻŋāϝāĻŧ⧇ initialize āĻ•āϰ⧇āĨ¤ &T{field: value} āĻĻāĻŋāϝāĻŧ⧇ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ­ā§āϝāĻžāϞ⧁ āĻĻ⧇āĻ“āϝāĻŧāĻž āϝāĻžāϝāĻŧ — production-āĻ &T{} āĻŦ⧇āĻļāĻŋ āĻŦā§āϝāĻŦāĻšā§ƒāϤāĨ¤

Q: Go-āϤ⧇ āĻ•āĻŋ Pass by Reference āφāϛ⧇?

āύ⧇āχāĨ¤ Go āϏāĻŦāϏāĻŽāϝāĻŧ Pass by ValueāĨ¤ Pointer āĻĒāĻžāϏ āĻ•āϰāϞ⧇āĻ“ address-āĻāϰ āĻāĻ•āϟāĻŋ copy āϝāĻžāϝāĻŧ — reference āϝāĻžāϝāĻŧ āύāĻžāĨ¤

Q: nil pointer dereference āϕ⧀āĻ­āĻžāĻŦ⧇ āĻāĻĄāĻŧāĻžāĻŦ⧇āύ?

Pointer āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āφāϗ⧇ āϏāĻŦāϏāĻŽāϝāĻŧ if ptr != nil āĻšā§‡āĻ• āĻ•āϰ⧁āύāĨ¤ āĻ…āĻĨāĻŦāĻž new() āĻŦāĻž &T{} āĻĻāĻŋāϝāĻŧ⧇ initialize āĻ•āϰ⧇ āύāĻŋāύāĨ¤