Wskaźniki w Golang: & i *, new, nil i kiedy ich używać

& i *

Wskaźnik przechowuje adres wartości w pamięci. &x daje wskaźnik na x. *p podąża za wskaźnikiem do wartości.

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)
}

Gwiazdka ma dwie role. W typie (*int) oznacza „wskaźnik na int”. W wyrażeniu (*p) oznacza „wartość, na którą wskazuje p”. Wypisanie samego p pokazuje adres w stylu 0xc000012345, który zmienia się między uruchomieniami.

Po co są wskaźniki: współdzielenie zamiast kopiowania

Go przekazuje wszystko przez wartość. Funkcja dostaje kopię każdego argumentu, więc nie może zmienić zmiennej kodu wywołującego. Przekazanie wskaźnika kopiuje zamiast tego adres i obie strony sięgają do tej samej wartości.

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 nie ma referencji w sensie C++. „Przekazywanie przez referencję” w Go oznacza przekazanie wskaźnika przez wartość.

Wskaźniki do struktur

Wskaźniki do struktur to najczęstsze wskaźniki w kodzie Go. Dostęp do pola automatycznie dereferencjonuje: p.Name oznacza (*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
}

Metody działają według tej samej logiki: odbiorca wskaźnikowy pozwala metodzie zmienić strukturę. Wybór między odbiorcą wartościowym a wskaźnikowym opisuje strona o metodach.

new

new(T) alokuje wyzerowane T i zwraca jego adres. To to samo co zadeklarowanie zmiennej i pobranie jej adresu.

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

W praktyce dla struktur częściej używa się &T{...}, bo pozwala ustawić pola w tym samym wyrażeniu. new przydaje się przy wskaźnikach na typy podstawowe. Nie myl go z make, które buduje slice'y, mapy i kanały i zwraca je gotowe do użycia, a nie jako wskaźniki.

Zwrócenie wskaźnika do zmiennej lokalnej jest bezpieczne

W C zwrócenie adresu zmiennej lokalnej to błąd. W Go to zwykły kod.

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)
}

Analiza ucieczki w kompilatorze decyduje, czy wartość żyje na stosie, czy na stercie. Nigdy tego nie wybierasz i nigdy nie zwalniasz pamięci: garbage collector odzyskuje ją, gdy nic już na nią nie wskazuje. go build -gcflags=-m wypisuje te decyzje, jeśli chcesz je zobaczyć.

Wskaźniki nil

Wartość zerowa każdego typu wskaźnikowego to nil. Dereferencja nil wywołuje panikę.

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
}

Wynik:

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

Bez recover program wywróciłby się z tym komunikatem i śladem stosu zaczynającym się od panic: runtime error: invalid memory address or nil pointer dereference i [signal SIGSEGV: segmentation violation ...]. Typowe źródła:

• zmienna wskaźnikowa albo pole struktury, które nigdy nie zostało ustawione
• m[key] na map[string]*T dla brakującego klucza, co zwraca nil
• zignorowanie błędu: f, _ := os.Open(path) zostawia przy niepowodzeniu f równe nil
• metoda z odbiorcą wskaźnikowym wywołana na wskaźniku nil, która potem czyta pole

Samo wywołanie metody na wskaźniku nil jest dozwolone. Panika pojawia się dopiero wtedy, gdy metoda dotknie pól odbiorcy.

Kiedy używać wskaźnika

Użyj wskaźnika, gdy:

• funkcja lub metoda musi zmienić wartość kodu wywołującego
• wartość to duża struktura, która często jest przekazywana
• typu nie wolno kopiować (zawiera sync.Mutex albo reprezentuje unikalny zasób, np. połączenie)
• potrzebujesz wyrazić „brak wartości” przez nil, np. opcjonalne pole w strukturze JSON (*int odróżnia „brak” od 0)

Nie używaj wskaźnika, gdy:

• wartość jest mała i tylko do odczytu (time.Time, Point)
• typ już zachowuje się jak referencja: slice'y, mapy, kanały, funkcje i interfejsy rzadko potrzebują * przed sobą. *[]int albo *map[string]int to prawie zawsze pomyłka

Wskaźniki nie są automatycznie szybsze. Kopiowanie małej struktury jest tanie, a wskaźnik może wymusić alokację na stercie i dołożyć pracy garbage collectorowi.

Wskaźniki i zmienne pętli

Pobieranie adresu zmiennej pętli jest bezpieczne od Go 1.22, bo każda iteracja ma własną zmienną:

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()
}

To wypisuje 0 1 2. Przed Go 1.22 (które wprowadziło też range 3) ta sama pętla zapisana jako for i := 0; i < 3; i++ wypisywała 3 3 3, bo wszystkie trzy wskaźniki współdzieliły jedną zmienną. Zwróć uwagę, że &v w for _, v := range items wskazuje na kopię elementu, a nie na element w slice'ie. Aby dostać wskaźnik na sam element, użyj &items[i].

Częste błędy

• Dereferencja bez sprawdzenia. Sprawdzaj if p == nil wszędzie tam, gdzie nil jest możliwy.
• Wskaźnik na wartość z range. &v wskazuje na kopię; użyj &s[i].
• Wskaźniki na slice'y i mapy. Rzadko potrzebne. Zamiast tego zwróć nowy slice.
• Trzymanie &s[i] przez append. Jeśli append realokuje pamięć, wskaźnik nadal odnosi się do starej tablicy, a późniejsze zapisy trafiają w miejsce, którego nikt nie widzi.