Pointer di Golang: & dan *, new, nil, dan Kapan Memakainya

& dan *

Pointer menyimpan alamat memori sebuah nilai. &x memberimu pointer ke x. *p mengikuti pointer itu ke nilainya.

package main

import "fmt"

func main() {
	x := 10
	p := &x // p has type *int

	fmt.Println(*p) // read through the pointer: 10
	*p = 20         // write through the pointer
	fmt.Println(x)  // x changed: 20

	fmt.Printf("%T\n", p)
	fmt.Println(p != nil)
}

Tanda bintang punya dua peran. Di dalam tipe (*int), artinya "pointer ke int". Di dalam ekspresi (*p), artinya "nilai yang ditunjuk p". Mencetak p itu sendiri menampilkan alamat seperti 0xc000012345, yang berbeda setiap kali program dijalankan.

Kenapa pointer ada: berbagi alih-alih menyalin

Go mengirim semuanya sebagai nilai (pass by value). Sebuah fungsi mendapat salinan setiap argumen, jadi ia tidak bisa mengubah variabel milik pemanggil. Mengirim pointer berarti yang disalin adalah alamatnya, dan kedua sisi menjangkau nilai yang sama.

package main

import "fmt"

func doubleCopy(n int) {
	n *= 2
}

func doublePtr(n *int) {
	*n *= 2
}

func main() {
	v := 21
	doubleCopy(v)
	fmt.Println(v) // 21

	doublePtr(&v)
	fmt.Println(v) // 42
}

Go tidak punya reference dalam arti seperti di C++. "Pass by reference" di Go berarti mengirim pointer sebagai nilai.

Pointer ke struct

Pointer ke struct adalah pointer yang paling sering muncul di kode Go. Akses field melakukan dereference secara otomatis: p.Name berarti (*p).Name.

package main

import "fmt"

type Account struct {
	Owner   string
	Balance int
}

func (a *Account) Deposit(n int) {
	a.Balance += n // no explicit * needed
}

func main() {
	acc := &Account{Owner: "Ana"} // pointer to a new struct
	acc.Deposit(100)
	acc.Balance -= 30
	fmt.Println(acc.Owner, acc.Balance)

	same := acc
	same.Balance = 0
	fmt.Println(acc.Balance) // 0: both variables point at one Account
}

Method mengikuti logika yang sama: pointer receiver memungkinkan method mengubah struct-nya. Halaman method membahas pilihan antara value receiver dan pointer receiver.

new

new(T) mengalokasikan T yang bernilai nol lalu mengembalikan alamatnya. Hasilnya sama dengan mendeklarasikan variabel lalu mengambil alamatnya.

p := new(int) // *int pointing at 0
var x int
q := &x           // same thing, two lines
a := new(Account) // same as &Account{}

Dalam praktiknya, &T{...} lebih umum untuk struct karena kamu bisa mengisi field-nya di ekspresi yang sama. new berguna untuk pointer ke tipe dasar. Jangan tertukar dengan make, yang membuat slice, map, dan channel lalu mengembalikannya dalam keadaan siap pakai, bukan sebagai pointer.

Mengembalikan pointer ke variabel lokal itu aman

Di C, mengembalikan alamat variabel lokal adalah bug. Di Go, itu kode yang biasa saja.

package main

import "fmt"

type Config struct {
	Port int
	Mode string
}

func defaultConfig() *Config {
	c := Config{Port: 8080, Mode: "dev"}
	return &c // c outlives the call, so it lives on the heap
}

func main() {
	cfg := defaultConfig()
	cfg.Mode = "prod"
	fmt.Printf("%+v\n", *cfg)
}

Escape analysis milik compiler memutuskan apakah sebuah nilai tinggal di stack atau di heap. Kamu tidak pernah memilihnya, dan kamu tidak pernah membebaskan memori: garbage collector mengambilnya kembali saat tidak ada lagi yang menunjuk ke sana. go build -gcflags=-m mencetak keputusan-keputusan itu kalau kamu penasaran.

Pointer nil

Zero value dari tipe pointer apa pun adalah nil. Melakukan dereference pada nil akan memicu panic.

package main

import "fmt"

type Node struct {
	Val  int
	Next *Node
}

func main() {
	defer func() {
		fmt.Println("recovered:", recover())
	}()

	list := &Node{Val: 1, Next: &Node{Val: 2}}
	for n := list; n != nil; n = n.Next {
		fmt.Println(n.Val)
	}

	var missing *Node
	fmt.Println(missing == nil)
	fmt.Println(missing.Val) // panics
}

Output:

1
2
true
recovered: runtime error: invalid memory address or nil pointer dereference

Tanpa recover, program akan crash dengan pesan itu dan stack trace yang diawali panic: runtime error: invalid memory address or nil pointer dereference dan [signal SIGSEGV: segmentation violation ...]. Sumber yang biasa:

• variabel pointer atau field struct yang tidak pernah diisi
• m[key] pada map[string]*T untuk key yang tidak ada, yang mengembalikan nil
• mengabaikan error: f, _ := os.Open(path) membiarkan f bernilai nil saat gagal
• method dengan pointer receiver yang dipanggil pada pointer nil, lalu membaca sebuah field

Memanggil method pada pointer nil itu sendiri sah. Panic baru terjadi saat method itu menyentuh field milik receiver.

Kapan memakai pointer

Pakai pointer saat:

• fungsi atau method harus mengubah nilai milik pemanggil
• nilainya berupa struct besar dan sering dikirim ke sana kemari
• tipenya tidak boleh disalin (berisi sync.Mutex, atau mewakili sumber daya unik seperti koneksi)
• kamu perlu menyatakan "tidak ada nilai" dengan nil, misalnya field opsional di struct JSON (*int membedakan "tidak ada" dari 0)

Jangan pakai pointer saat:

• nilainya kecil dan hanya dibaca (time.Time, sebuah Point)
• tipenya sudah berupa nilai yang mirip referensi: slice, map, channel, fungsi, dan interface jarang butuh * di depannya. *[]int atau *map[string]int hampir selalu merupakan kesalahan

Pointer tidak otomatis lebih cepat. Menyalin struct kecil itu murah, dan pointer bisa memaksa alokasi di heap serta menambah pekerjaan garbage collector.

Pointer dan variabel loop

Mengambil alamat variabel loop aman sejak Go 1.22, karena setiap iterasi punya variabelnya sendiri:

package main

import "fmt"

func main() {
	var ptrs []*int
	for i := range 3 {
		ptrs = append(ptrs, &i)
	}
	for _, p := range ptrs {
		fmt.Print(*p, " ")
	}
	fmt.Println()
}

Program ini mencetak 0 1 2. Sebelum Go 1.22 (yang juga memperkenalkan range 3), loop yang sama ditulis sebagai for i := 0; i < 3; i++ mencetak 3 3 3, karena ketiga pointer berbagi satu variabel. Perhatikan bahwa &v dalam for _, v := range items menunjuk ke salinan elemen, bukan elemen di dalam slice. Untuk mendapatkan pointer ke elemen itu sendiri, pakai &items[i].

Kesalahan umum

• Melakukan dereference tanpa pemeriksaan. Periksa if p == nil di mana pun nil mungkin muncul.
• Pointer ke nilai range. &v menunjuk ke salinan; pakai &s[i].
• Pointer ke slice dan map. Jarang dibutuhkan. Kembalikan slice yang baru saja.
• Menyimpan &s[i] melewati append. Kalau append mengalokasikan ulang, pointer itu masih merujuk ke array lama dan penulisan berikutnya tidak terlihat di mana pun.