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

`&` ஒரு variable-ன் முகவரியை எடுக்கிறது; `*` (ஒரு 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 caller-ன் தரவை மாற்ற முடியாது **pointer** அது பெறாத வரை. இது 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 என்பது 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 செய்வது panics செய்கிறது — guard செய்ய வேண்டிய ஒரு பொதுவான 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-வில் இரண்டு முக்கிய நோக்கங்களுக்கு அவசியம்: caller-ன் தரவை **மாற்றுதல்** (Go by value அனுப்புவதால், ஒரு function மூல-ஐ மாற்ற pointer மட்டுமே விடுகிறது) மற்றும் **efficiency** (pointer அனுப்புவது பெரிய structs ஐ நகல் செய்வதைத் தவிர்க்கிறது).

அவை pointer receivers உடன் methods-ற்கு அடிப்படையாக உள்ளன (structs ஐ பரிமாற்றம் செய்ய வேண்டிய நிலையான வழி) மற்றும் idiomatically Go முழுவதும் தோன்றுகிறது.

`&`/`*`, value-vs-pointer semantics, nil-pointer panic, மற்றும் Go pointers deliberately *safe* (arithmetic இல்லை, GC-managed) — sharing/mutation-ற்கு கவனம், C-style memory manipulation க்கு அல்ல — சரியான, efficient Go எழுத அடிப்படை அறிவு மற்றும் newcomers மற்றும் interviews-ல் கடினமான பொருள்.