Указатели в Golang: & и *, new, nil и когда их использовать

& и *

Указатель хранит адрес значения в памяти. &x даёт указатель на x. *p переходит по указателю к значению.

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

У звёздочки две роли. В типе (*int) она означает «указатель на int». В выражении (*p) она означает «значение, на которое указывает p». Если напечатать сам p, получится адрес вроде 0xc000012345, который меняется от запуска к запуску.

Зачем нужны указатели: общий доступ вместо копирования

Go передаёт всё по значению. Функция получает копию каждого аргумента, поэтому не может изменить переменную вызывающего кода. Передача указателя копирует адрес, и обе стороны добираются до одного и того же значения.

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
}

Ссылок в смысле C++ в Go нет. «Передача по ссылке» в Go означает передачу указателя по значению.

Указатели на структуры

Указатели на структуры это самые частые указатели в коде на Go. Обращение к полю разыменовывает автоматически: p.Name означает (*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
}

Методы подчиняются той же логике: получатель-указатель позволяет методу менять структуру. Выбор между получателем-значением и получателем-указателем разобран на странице о методах.

new

new(T) выделяет обнулённое значение T и возвращает его адрес. Это то же самое, что объявить переменную и взять её адрес.

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

На практике для структур чаще пишут &T{...}, потому что так можно задать поля в том же выражении. new удобен для указателей на базовые типы. Не путайте его с make, который создаёт слайсы, мапы и каналы и возвращает их готовыми к работе, а не указателями.

Возвращать указатель на локальную переменную безопасно

В C возврат адреса локальной переменной это баг. В Go это обычный код.

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-анализ компилятора. Вы этого никогда не выбираете и никогда не освобождаете память: сборщик мусора забирает её, когда на неё больше ничего не указывает. go build -gcflags=-m печатает эти решения, если интересно.

nil-указатели

Нулевое значение любого типа указателя это nil. Разыменование nil вызывает панику.

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
}

Вывод:

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

Без recover программа упала бы с этим сообщением и трассировкой стека, начинающейся с panic: runtime error: invalid memory address or nil pointer dereference и [signal SIGSEGV: segmentation violation ...]. Типичные источники:

• переменная-указатель или поле структуры, которым так и не присвоили значение
• m[key] в map[string]*T для отсутствующего ключа, что возвращает nil
• проигнорированная ошибка: f, _ := os.Open(path) оставляет f равным nil при неудаче
• метод с получателем-указателем, вызванный на nil-указателе, который затем читает поле

Сам вызов метода на nil-указателе допустим. Паника случается, только когда метод обращается к полям получателя.

Когда использовать указатель

Используйте указатель, когда:

• функция или метод должны изменить значение вызывающего кода
• значение это большая структура, которую часто передают
• тип нельзя копировать (он содержит sync.Mutex или представляет уникальный ресурс, например соединение)
• нужно выразить «нет значения» через nil, например необязательное поле в JSON-структуре (*int отличает «отсутствует» от 0)

Не используйте указатель, когда:

• значение маленькое и только для чтения (time.Time, Point)
• тип и так ведёт себя как ссылка: слайсам, мапам, каналам, функциям и интерфейсам * перед ними нужен редко. *[]int или *map[string]int почти всегда ошибка

Указатели не быстрее автоматически. Копировать маленькую структуру дёшево, а указатель может вынудить выделение в куче и добавить работы сборщику мусора.

Указатели и переменные цикла

Брать адрес переменной цикла безопасно начиная с Go 1.22, потому что у каждой итерации своя переменная:

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

Программа печатает 0 1 2. До Go 1.22 (где также появился range 3) тот же цикл, записанный как for i := 0; i < 3; i++, печатал 3 3 3, потому что все три указателя делили одну переменную. Учтите, что &v в for _, v := range items указывает на копию элемента, а не на элемент слайса. Чтобы получить указатель на сам элемент, используйте &items[i].

Частые ошибки

• Разыменование без проверки. Проверяйте if p == nil везде, где возможен nil.
• Указатель на значение из range. &v указывает на копию; используйте &s[i].
• Указатели на слайсы и мапы. Нужны редко. Лучше возвращайте новый слайс.
• Хранение &s[i] при append. Если append перевыделит память, указатель останется на старом массиве, и записи через него не будут видны в новом слайсе.