Bagaimanakah petunjuk berfungsi dalam Go?

Question

Accepted Answer

**Petunjuk** memegang **alamat ingatan** nilai daripada nilai itu sendiri. Go mempunyai petunjuk (seperti C) tetapi menyimpannya mudah dan selamat — tiada aritmetik petunjuk, dan pengumpul sampah menangani ingatan. Ia digunakan untuk berkongsi dan mengubah data dengan cekap.

## Dua operator: & dan *

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

`&` mengambil alamat pembolehubah; `*` (pada petunjuk) mengakses atau menetapkan nilai yang ditunjuknya.

## Mengapa petunjuk penting: mengubah melalui fungsi

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

Oleh kerana Go melewatkan argumen **mengikut nilai** (salinan), fungsi hanya boleh mengubah data pemanggil jika ia menerima **petunjuk** kepadanya. Ini adalah sebab utama untuk menggunakan petunjuk.

## Petunjuk dengan struct (sangat biasa)

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

Penerima petunjuk adalah cara kaedah mengubah struct mereka, dan melewatkan penunjuk struct mengelakkan penyalinan struct besar.

## Petunjuk nil dan nilai sifar

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

Mereferensikan petunjuk `nil` panik — ralat masa larian biasa yang perlu dijaga.

## Apa yang petunjuk Go TIDAK ada (keselamatan)

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

## Mengapa ia penting

Petunjuk adalah penting dalam Go untuk dua tujuan utama: **mengubah** data pemanggil (kerana Go melewatkan mengikut nilai, hanya petunjuk membenarkan fungsi mengubah yang asal) dan **kecekapan** (melewatkan petunjuk mengelakkan penyalinan struct besar).

Mereka adalah penting untuk kaedah dengan penerima petunjuk (cara piawai untuk mengubah struct) dan muncul di seluruh Go idiomatik.

Memahami `&`/`*`, semantik nilai-vs-petunjuk, panik petunjuk-nil, dan bahawa petunjuk Go dengan sengaja *selamat* (tiada aritmetik, diurus GC) — tertumpu pada perkongsian/mutasi daripada manipulasi ingatan gaya C — adalah pengetahuan teras untuk menulis Go yang betul dan cekap dan titik kekeliruan yang kerap bagi pendatang baru dan dalam temu duga.