Kaip žymekliai veikia Go?

Question

Accepted Answer

**Žymeklis** laikyti atminties **adresą** iš vertės, o ne pačią vertę. Go turi žymeklius (kaip C), bet juos išlaiko paprastus ir saugius — nėra žymeklio aritmetikos, o šiukšlių surinktuvas tvarko atmintį. Jie naudojami duomenims efektyviai dalytis ir jų keisti.

## Du operatoriai: & ir *

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

`&` paima kintamojo adresą; `*` (žymeklyje) pasiekia arba nustato reikšmę, į kurią jis rodo.

## Kodėl žymekliai yra svarbūs: modifikavimas per funkcijas

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

Kadangi Go praeina argumentai **pagal reikšmę** (kopijuoti), funkcija gali keisti tik skambintojo duomenis, jei ji gauna **žymeklį** į juos. Tai yra pagrindinė priežastis naudoti žymeklius.

## Žymekliai su struktūromis (labai dažnai)

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

Žymeklio imtuvas – tai būdas, kaip metodai modifikuoja savo struktūrą, o struktūros žymeklių perėmimas išvengia didelių struktūrų kopijavimo.

## Nil žymeklis ir nulinė reikšmė

```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 žymeklio dereferencijimas — panika — bendra atliekos klaida, kurios reikia saugotis.

## Ką Go žymekliai neturi (saugumas)

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

## Kodėl tai svarbu

Žymekliai Go yra esminiai dviem pagrindiniais tikslais: skambintojo duomenų **modifikavimas** (kadangi Go praeina pagal reikšmę, tik žymeklis leidžia funkcijai pakeisti originalą) ir **efektyvumas** (žymeklio perėmimas išvengia didelių struktūrų kopijavimo).

Jie yra būtini metodams, kurių imtuvai yra žymekliai (standartinis būdas keisti struktūras), ir pasirodo visame idiominiame Go.

Suprasti `&`/`*`, reikšmės ir žymeklio semantiką, nil žymeklio paniką ir tai, kad Go žymekliai yra sąmoningai *saugūs* (nėra aritmetikos, GC valdomi) — sutelkti dėmesį į dalijimąsi/modifikavimą, o ne C stiliaus atminties manipuliavimą — yra pagrindinės žinios, kaip rašyti teisingą ir efektyvų Go ir dažna pamiršimo vieta naujiems ateinantiems ir pokalbių metu.