Si funksionojnë pointerët në Go?

Question

Accepted Answer

Një **pointer** mban **adresën e memories** të një vlere në vend të vetë vlerës. Go ka pointerë (si C) por i mban ata të thjeshtë dhe të sigurt — nuk ka aritmetikë pointerësh, dhe garbage collector-i menaxhon memorien. Ata përdoren për të ndarë dhe modifikuar të dhënat në mënyrë efikase.

## Dy operatorët: & dhe *

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

`&` merr adresën e një ndryshoreje; `*` (në një pointer) akseson ose vendos vlerën në të cilën ai tregon.

## Pse pointerët kanë rëndësi: modifikimi përmes funksioneve

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

Duke qenë se Go kalon argumentet **sipas vlerës** (kopje), një funksion mund të modifikojë të dhënat e thirrësit vetëm nëse merr një **pointer** në to. Ky është arsyeja kryesore për të përdorur pointerë.

## Pointerët me struktura (shumë të zakonshëm)

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

Marrësit pointer janë mënyra se si metodat mutojnë strukturën e tyre, dhe kalimi i pointerëve të strukturës shmang kopjimin e strukturave të mëdha.

## Pointeri nil dhe vlera 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
```

Dereferencimi i një pointeri `nil` shkakton panik — një gabim të shpeshtë në kohën e ekzekutimit që duhet të mbrohet.

## Çfarë pointerët në Go NUK kanë (siguria)

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

## Pse ka rëndësi

Pointerët janë thelbësorë në Go për dy qëllime kryesore: **modifikimi** i të dhënave të thirrësit (pasi Go kalon sipas vlerës, vetëm një pointer lejon një funksion të ndryshojë origjinalin) dhe **efikasiteti** (kalimi i një pointeri shmang kopjimin e strukturave të mëdha).

Ata janë thelbësorë për metodat me marrës pointer (mënyra standarde për të mutuar strukturat) dhe shfaqen në të gjithë Go-n idiomatic.

Kuptime i `&`/`*`, semantikës vlerë-vs-pointer, panikut të pointer nil, dhe fakti se pointerët në Go janë qëllimisht *të sigurt* (nuk ka aritmetikë, menaxhuar nga GC) — i fokusuar në ndarje/mutacion në vend të manipulimit të memories në stil C — është njohja bazë për të shkruar Go-n korrekt dhe efikas dhe është një pikë e shpeshtë e konfuzionit për fillestarët dhe në intervista.