Go లో pointers ఎలా పని చేస్తాయి?

Question

Accepted Answer

**pointer** ఒక విలువ కంటే విలువ యొక్క **memory address** ను కలిగి ఉంటుంది. Go కి pointers ఉన్నాయి (C లాగా) కానీ అవి సరళమైనవి మరియు సురక్షితమైనవి — pointer arithmetic లేదు, మరియు garbage collector మెమరీని నిర్వహిస్తుంది. డేటాను సామర్థ్యవంతంగా భాగస్వామ్యం చేయడానికి మరియు సవరించడానికి ఉపయోగిస్తారు.

## రెండు 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
```

`&` ఒక వేరియబుల్ యొక్క చిరునామాను తీసుకుంటుంది; `*` (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** (కాపీలు) పాస్ చేస్తుంది కాబట్టి, ఒక function కేవలం అది **pointer** నుండి అందిస్తే caller యొక్క డేటాను సవరించగలదు. ఇది pointers ఉపయోగించటానికి ప్రధాన కారణం.

## 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 వాటి 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 చేయడం panics కలిగిస్తుంది — రక్షించడానికి ఒక సాధారణ runtime error.

## Go pointers కలిగి లేనివి (safety)

```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 లో రెండు ప్రధాన ప్రయోజనాల కోసం అవసరం: **modifying** caller యొక్క డేటా (Go by value పాస్ చేస్తుంది కాబట్టి, కేవలం ఒక pointer ఒక function నుండి అసలు సవరించడానికి అనుమతిస్తుంది) మరియు **efficiency** (pointer ను పాస్ చేయడం పెద్ద structs ను కాపీ చేయడాన్ని నివారిస్తుంది).

వాటి pointer receivers (structs ను mutate చేయడానికి ప్రామాణిక విధానం) ఇన్నుండిన methods కు ప్రాథమికమైనవి మరియు idiomatic Go లో కనిపిస్తాయి.

`&`/`*`, value-vs-pointer semantics ను అర్థం చేసుకోవడం, nil-pointer panic, మరియు Go pointers ఉద్దేశపూర్వకంగా *safe* (arithmetic లేదు, GC-managed) — C-style memory manipulation కంటే sharing/mutation పై దృష్టి సారించడం — సరైన, సామర్థ్యవంతమైన Go ను రాయడానికి ప్రధాన జ్ఞానం మరియు newcomers మరియు interviews లో విభేదం యొక్క తరచుగా పాయింట్.