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

`&` ચલનો સરનામું લે છે; `*` (pointer પર) તે જે મૂલ્યને નિર્દેશ કરે છે તે સુધી પહોંચે છે અથવા તેને સેટ કરે છે.

## પોઇન્ટર્સ કેમ મહત્વપૂર્ણ છે: ફંક્શન દ્વારા સુધારો કરવો

```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 આર્ગુમેન્ટ્સને **મૂલ્ય દ્વારા** (copies) પાસ કરે છે, તેથી ફંક્શન શક્તર કેલર ડેટામાં સુધારો કર્યો શકે છે જો તે તેને **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 value દ્વારા પાસ કરે છે, કેવળ pointer ફંક્શને મૂળમાં બદલવા દે છે) અને **કાર્યક્ષમતા** (pointer પાસ કરવું મોટી structs ની નકલ ટાળે છે)।

તે pointer receivers સાથે methods માટે મૌલિક છે (structs માં ફેરફાર કરવાનો માનક રસ્તો) અને તમામ idiomatic Go માં દેખાય છે.

`&`/`*` સમજવું, value-vs-pointer semantics, nil-pointer panic, અને Go pointers ઉદ્દેશ્ય દ્વારા *સુરક્ષિત* છે (કોઇ અંકગણિત નથી, GC-managed) — C-style મેમોરી હેરફેર કરવાને બદલે sharing/mutation પર ધ્યાન કેન્દ્રિત — સાચા, કુશળ Go લખવા માટે મૂલ્યવાન જ્ઞાન છે અને નવીનતમ અને interview માં મેળવવામાં આવતો મુશ્કેલ બિંદુ છે।