Cum funcționează pointerii în Go?

Question

Accepted Answer

Un **pointer** stochează **adresa de memorie** a unei valori în loc de valoarea în sine. Go are pointeri (ca și C), dar îi păstrează simpli și siguri — fără aritmetică pe pointeri, iar garbage collector-ul se ocupă de memorie. Sunt folosiți pentru a partaja și modifica date eficient.

## Cei doi operatori: & și *

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

`&` ia adresa unei variabile; `*` (pe un pointer) accesează sau stabilește valoarea la care pointează.

## De ce pointerii sunt importanți: modificarea prin funcții

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

Deoarece Go transmite argumente **după valoare** (copii), o funcție poate modifica datele apelantului doar dacă primește un **pointer** la acestea. Aceasta este motivul principal pentru utilizarea pointerilor.

## Pointeri cu structuri (foarte frecvent)

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

Receptorii pointer sunt modul în care metodele mutează structura lor, iar transmiterea pointerilor la struct evită copierea structurilor mari.

## Pointerul nil și valoarea zero

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

Dereferencierea unui pointer `nil` provoacă o panică — o eroare comună la runtime pe care trebuie să o protejezi.

## Ce NU au pointerii Go (siguranță)

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

## De ce este important

Pointerii sunt esențiali în Go pentru două scopuri principale: **modificarea** datelor apelantului (deoarece Go transmite după valoare, doar un pointer permite unei funcții să schimbe originalul) și **eficiență** (transmiterea unui pointer evită copierea structurilor mari).

Sunt fundamentali pentru metodele cu receptori pointer (modul standard de a muta structuri) și apar în întregul Go idiomul.

Înțelegerea `&`/`*`, semantica valoare-versus-pointer, panica pointer-ului nil și faptul că pointerii Go sunt deliberat *siguri* (fără aritmetică, gestionați de GC) — concentrați pe partajare/mutație în loc de manipulare de memorie în stil C — este cunoaștere esențială pentru a scrie cod Go corect și eficient și este un punct frecvent de confuzie pentru începători și la interviuri.