Go में पॉइंटर्स कैसे काम करते हैं?

Question

Accepted Answer

एक **pointer** किसी मान के बजाय उसका **मेमोरी पता** रखता है। Go के पास पॉइंटर्स हैं (C की तरह) लेकिन उन्हें सरल और सुरक्षित रखता है — कोई पॉइंटर अंकगणित नहीं, और garbage collector मेमोरी को संभालता है। इनका उपयोग डेटा को साझा करने और कुशलतापूर्वक संशोधित करने के लिए किया जाता है।

## दो ऑपरेटर: & और *

```go
x := 42
p := &x          // & = "address of" → p is a *int (pointer to x)
fmt.Println(p)   // 0xc0000... (the address)
fmt.Println(*p)  // 42 — * = "dereference" (get the value at the address)

*p = 100         // change the value THROUGH the pointer
fmt.Println(x)   // 100 — x was modified via p
```

`&` एक चर का पता लेता है; `*` (एक पॉइंटर पर) इसके द्वारा इंगित मान तक पहुंचता है या सेट करता है।

## पॉइंटर्स क्यों महत्वपूर्ण हैं: फ़ंक्शन द्वारा संशोधन

```go
// ❌ value parameter — the function gets a COPY; changes don't affect the caller
func incrementValue(n int) { n++ }       // caller's variable unchanged

// ✅ pointer parameter — the function can modify the caller's variable
func incrementPointer(n *int) { *n++ }

x := 5
incrementValue(x)     // x still 5
incrementPointer(&x)  // x is now 6
```

चूंकि Go तर्कों को **मान के आधार पर** (प्रतियां) पास करता है, एक फ़ंक्शन केवल कॉलर के डेटा को संशोधित कर सकता है यदि उसे इसका **pointer** मिले। यह पॉइंटर्स का उपयोग करने का मुख्य कारण है।

## Structs के साथ Pointers (बहुत आम)

```go
type Counter struct { count int }

// pointer receiver → method can modify the struct
func (c *Counter) Increment() { c.count++ }

c := &Counter{}      // a pointer to a Counter
c.Increment()        // modifies it (Go auto-dereferences: (*c).count++)
```

Pointer receivers वह तरीका है जिससे methods अपने struct को संशोधित करते हैं, और struct pointers को पास करने से बड़े structs की प्रतिलिपि बनाने से बचा जा सकता है।

## nil pointer और zero value

```go
var p *int           // zero value of a pointer is nil
fmt.Println(p)       // <nil>
*p = 5               // 💥 PANIC: nil pointer dereference (no value to point to)
if p != nil { *p = 5 }   // guard against nil
```

`nil` pointer को dereference करना panic का कारण बनता है — एक सामान्य runtime error जिससे रक्षा करनी चाहिए।

## Go pointers के पास क्या नहीं है (सुरक्षा)

```text
✗ NO pointer arithmetic (can't do p++ to move through memory like C)
✗ NO manual free — garbage collector reclaims memory
→ Pointers are about sharing/modifying data, not low-level memory hacking
```

## यह क्यों महत्वपूर्ण है

Pointers Go में दो मुख्य उद्देश्यों के लिए आवश्यक हैं: कॉलर के **डेटा को संशोधित** करना (क्योंकि Go मान के आधार पर पास करता है, केवल एक pointer फ़ंक्शन को मूल को बदलने देता है) और **दक्षता** (pointer पास करने से बड़े structs की प्रतिलिपि बनाने से बचा जा सकता है)।

ये pointer receivers वाली methods के लिए मौलिक हैं (structs को संशोधित करने का मानक तरीका) और idiomatic Go में सर्वत्र दिखाई देते हैं।

`&`/`*`, value-vs-pointer semantics, nil-pointer panic को समझना, और यह कि Go pointers जानबूझकर *सुरक्षित* हैं (कोई अंकगणित नहीं, GC-managed) — C-शैली मेमोरी हेरफेर के बजाय साझाकरण/संशोधन पर केंद्रित — सही, कुशल Go लिखने के लिए मौलिक ज्ञान है और नए लोगों और साक्षात्कार में भ्रम का एक सामान्य बिंदु है।