Go मा pointers कसरी काम गर्छन्?

Question

Accepted Answer

एक **pointer** ले मानको **memory address** राख्छ, मान आफैलाई होइन। Go मा pointers छन् (C जस्तै) तर तिनीहरूलाई सरल र सुरक्षित राखछ — कोनै pointer arithmetic छैन, र garbage collector ले memory सम्भाल्छ। तिनीहरू डेटा साझेदारी गर्न र कुशलतापूर्वक परिमार्जन गर्न प्रयोग गरिन्छन्।

## दुई operators: & र *

```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
```

`&` ले एक चल को address लिन्छ; `*` (एक pointer मा) यो जनाउने मान पहुँच गर्छ वा सेट गर्छ।

## किन pointers महत्त्वपूर्ण छन्: functions मार्फत परिमार्जन

```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 ले arguments **by value** (copies) को रूपमा पास गर्दछ, एक function ले केवल कलकर्ताको डेटा परिमार्जन गर्न सक्छ यदि यसले यसको **pointer** प्राप्त गर्छ। यो pointers प्रयोग गर्नको प्राथमिक कारण हो।

## Pointers structs को साथ (धेरै सामान्य)

```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 को प्रतिलिपि गर्न बचाउछ।

## The 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 त्रुटि जनाई राख्नको लागि।

## 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 by value पास गर्दछ, केवल एक pointer ले function लाई मूलको परिवर्तन गर्न दिन्छ) र **दक्षता** (एक pointer पास गर्दा ठूला structs को प्रतिलिपि बचाउछ)।

तिनीहरू pointer receivers को साथ methods को लागि मौलिक छन् (structs परिमार्जन गर्नको मानक तरिका) र idiomatic Go भर मा देखा पर्छन्।

`&`/`*` बुझ्न, value-vs-pointer semantics, nil-pointer panic, र कि Go pointers जानसारी *सुरक्षित* छन् (कोनै arithmetic छैन, GC-managed) — साझेदारी/परिमार्जनमा केन्द्रित C-style memory manipulation को सट्टा — सही, कुशल Go लेखन को लागि मुख्य ज्ञान हो र नविश्कहरू र interviews मा भ्रमको बिन्दु।