Conas a bhíonn pointeoir ag feidhmiú i Go?

Question

Accepted Answer

Coimeádann **pointeoir** an **seoladh cuimhne** de luach seachas an luach féin. Tá pointeoir ag Go (cosúil le C) ach coimeádann siad go simplí agus sábhálte — gan uimhríocht pointeoir, agus bainistríonn an garbhshliotáir cuimhne. Úsáidtear iad chun sonraí a roinnt agus a mhodhnú go héifeachtach.

## An dá oibreoir: & agus *

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

Tógann `&` seoladh athróige; rochtain `*` (ar pointeoir) ar an luach ar a bhfuil sé ag díriú nó a socraíonn sé é.

## Cén fáth a bhíonn pointeoir ábhairín: a mhodhnú trí fheidhmeanna

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

De bharr go gcuireann Go argóintí **de réir luacha** (cóipeanna), ní féidir le feidhm ach sonraí an ghlaochóra a mhodhnú má fhaigheann sí **pointeoir** chuici. Is é seo an príomhúchúis a bheith ag úsáid pointeoir.

## Pointeoir le structs (an-coitianta)

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

Bealach a bhíonn ag modhanna le glacadóirí pointeoir a oibríonn ar a gcuid struct, agus pointeoir struct a chur ar aghaidh a sheachaint cóipeanna de structs mhór.

## An pointeoir nil agus an luach nialasach

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

Bíonn dírdhéanamh pointeoir `nil` á dhéanamh páinic — earráid runtime choitianta a chosaint ina choinne.

## Cad nach bhfuil ag pointeoir Go (sábháilteacht)

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

## Cén fáth a bhíonn sé ábhairín

Tá pointeoir riachtanach i Go ar dhá chúis phríomha: **sonraí an ghlaochóra a mhodhnú** (de bharr go gcuireann Go ar aghaidh de réir luacha, lig do pointeoir amháin feidhm an bunaidh a athrú) agus **éifeachtúlacht** (pointeoir a chur ar aghaidh a sheachaint cóipeanna de structs mhór).

Tá siad bunúsach do mhodhanna le glacadóirí pointeoir (an bealach caighdeánach chun structs a athrú) agus bíonn siad ina n-aonad ar fud Go idiomatach.

A thuiscint `&`/`*`, séimeantaic luacha-vs-pointeoir, páinic an pointeoir nil, agus gur bhí pointeoir Go go geal *sábháilte* (gan uimhríocht, bainistríonn GC) — dírithe ar roinnt/athrú seachas ionramháil chuimhne stíl C — is eolas bunúsach é chun Go ceart, éifeachtach a scríobh agus pointe mearbhaill is minic do dhéagóirí agus in agallaimh.