Цели главы
- Понимать операторы
&и*и тип указателя. - Менять оригинальную переменную из функции.
- Работать с указателями на структуры и
new. - Безопасно обращаться с
nilи использовать указатель как опциональное значение. - Знать, почему возврат указателя на локальную переменную безопасен.
Зачем указатели
Функции в Go получают копию аргумента (05 — Функции → Передача по значению). Это безопасно, но что, если нужно изменить оригинал — например, обновить рейтинг фильма из функции? Функция работает с копией, и снаружи изменения не видны. Указатели решают эту проблему.
& и *
Указатель — адрес переменной в памяти. Два оператора:
&(амперсанд) — взять адрес переменной;*(звёздочка) — разыменовать указатель: обратиться к значению по адресу.
У указателя есть свой тип: *int — указатель на int. Положить в такую переменную адрес string не получится — код не скомпилируется.
package main
import "fmt"
func main() {
movieID := 42
ptr := &movieID // ptr хранит адрес movieID
fmt.Println("movieID =", movieID)
fmt.Println("*ptr =", *ptr) // значение по адресу
fmt.Printf("тип ptr: %T\n", ptr)
fmt.Println("адрес:", ptr)
// недетерминированный вывод: адрес меняется от запуска к запуску
}Пример вывода — адрес у тебя будет другим:
movieID = 42
*ptr = 42
тип ptr: *int
адрес: 0x14000110018Аналогия: указатель — адрес дома. & — записать адрес на бумажке или продиктовать его. * — пойти по адресу и посмотреть на сам дом.
Изменение через указатель
Разыменуй указатель и запиши новое значение — изменится оригинальная переменная, ведь обе смотрят на одну область памяти.
package main
import "fmt"
func main() {
viewCount := 1000
viewPtr := &viewCount
*viewPtr = 5000 // «по адресу из viewPtr запиши 5000»
fmt.Println(viewCount)
}5000Указатели в параметрах функций
Без указателя функция получает копию и меняет копию — оригинал цел. С указателем функция получает адрес и меняет оригинал.
package main
import "fmt"
// tryChangeRating получает копию — оригинал не изменится.
func tryChangeRating(r float64) {
r = 10.0
}
// changeRating получает адрес и меняет оригинал.
func changeRating(r *float64, newRating float64) {
*r = newRating
}
func main() {
rating := 8.0
tryChangeRating(rating)
fmt.Println("после tryChangeRating:", rating)
changeRating(&rating, 9.5)
fmt.Println("после changeRating:", rating)
}после tryChangeRating: 8
после changeRating: 9.5Указатели на структуры
Указатели особенно полезны со структурами: большую структуру дорого копировать, поэтому её передают по указателю. При этом в Go есть автоматическое разыменование: вместо (*p).Views пишут просто p.Views — Go сам подставит *. Подробно структуры — в 15 — Структуры.
package main
import "fmt"
type Movie struct {
Title string
Rating float64
Views int
}
func addView(m *Movie) {
m.Views++ // то же, что (*m).Views++ — Go разыменует сам
}
func main() {
film := Movie{Title: "Довод", Rating: 7.8, Views: 50000}
addView(&film)
addView(&film)
fmt.Println(film.Views)
p := &film
p.Rating = 8.0
fmt.Println(film.Rating, (*p).Title, p.Title)
}50002
8 Довод Доводnew
Встроенная функция new(T) создаёт переменную типа T с нулевым значением и возвращает указатель на неё. Используется нечасто: обычно проще взять адрес через &.
package main
import "fmt"
func main() {
numPtr := new(int) // *int, указывает на 0
fmt.Println(*numPtr)
*numPtr = 999
fmt.Println(*numPtr)
rating := 0.0
same := &rating // то же самое, но привычнее
*same = 8.5
fmt.Println(rating)
}0
999
8.5nil-указатель
Нулевое значение указателя — nil: указатель никуда не указывает. Разыменовать его — паника.
package main
import "fmt"
func main() {
var p *int
fmt.Println(*p) // ожидается panic
}panic: runtime error: invalid memory address or nil pointer dereferenceПоэтому перед разыменованием указатель проверяют:
package main
import "fmt"
func main() {
var p *int
fmt.Println(p == nil, p)
if p != nil {
fmt.Println(*p) // без проверки здесь была бы паника
}
}true <nil>Указатель как опциональное значение
Полезный паттерн: nil означает «значение не задано», не-nil — «задано». Так различают две ситуации, которые обычный float64 не различает: «пользователь не поставил оценку» и «поставил 0».
package main
import "fmt"
func printUserRating(name string, rating *float64) {
if rating == nil {
fmt.Printf("%s: не оценил\n", name)
return
}
fmt.Printf("%s: %.1f\n", name, *rating)
}
func main() {
score := 8.5
zero := 0.0
printUserRating("Алексей", &score)
printUserRating("Мария", nil)
printUserRating("Олег", &zero) // поставил 0 — это не то же самое, что «не оценил»
}Алексей: 8.5
Мария: не оценил
Олег: 0.0Возврат указателя на локальную переменную
В C и C++ это опасно: локальная переменная умирает при выходе из функции. В Go — безопасно: компилятор видит, что на переменную ещё ссылаются, и размещает её не на стеке, а в куче. Там она живёт, пока на неё есть указатель, а потом её уберёт сборщик мусора.
package main
import "fmt"
type Movie struct {
Title string
Rating float64
}
func createMovie(title string, rating float64) *Movie {
m := Movie{Title: title, Rating: rating}
return &m // безопасно: компилятор перенесёт m в кучу
}
func main() {
film := createMovie("Оппенгеймер", 8.5)
fmt.Println(*film)
fmt.Printf("%+v\n", film)
}{Оппенгеймер 8.5}
&{Title:Оппенгеймер Rating:8.5}Ссылочные типы
Слайсы, мапы и каналы уже содержат указатель внутри. Передаются они тоже по значению, но копируется только маленький заголовок, а данные остаются общими. Поэтому указатель на них обычно не нужен: изменения элементов видны снаружи.
package main
import "fmt"
func modifySlice(s []string) {
if len(s) > 0 {
s[0] = "ИЗМЕНЁН"
}
}
func modifyMap(m map[string]float64) {
m["Гладиатор"] = 8.6
}
func main() {
films := []string{"A", "B", "C"}
modifySlice(films)
fmt.Println(films)
scores := map[string]float64{"Дюна": 8.1}
modifyMap(scores)
fmt.Println(scores)
}[ИЗМЕНЁН B C]
map[Гладиатор:8.6 Дюна:8.1]Итоги
Зачем нужны указатели:
- Менять оригинальную переменную из функции.
- Не копировать большие структуры.
- Выражать опциональные значения:
nil— не задано.
Правила работы:
- Проверяй указатель на
nilперед разыменованием. - Go сам разыменовывает указатель на структуру при обращении к полям.
- Вернуть из функции указатель на локальную переменную — безопасно.
- Слайсы и мапы уже ссылочные — указатель на них обычно не нужен.
Практика
- Напиши
swap(a, b *int), которая меняет местами значения двух переменных. - Напиши
applyDiscount(priceKopecks *int, percent int), которая уменьшает цену на процент. Вызов сnilне должен паниковать. - Напиши
averageRated(ratings []*float64) (float64, int)— средняя оценка и число оценок;nilв слайсе означает «не оценил» и пропускается.
решениеЭталонное решение
package main
import "fmt"
func swap(a, b *int) {
*a, *b = *b, *a
}
func applyDiscount(priceKopecks *int, percent int) {
if priceKopecks == nil {
return
}
*priceKopecks = *priceKopecks * (100 - percent) / 100
}
func averageRated(ratings []*float64) (float64, int) {
sum, count := 0.0, 0
for _, r := range ratings {
if r == nil {
continue // пользователь не оценил
}
sum += *r
count++
}
if count == 0 {
return 0, 0
}
return sum / float64(count), count
}
func main() {
x, y := 1, 2
swap(&x, &y)
fmt.Println(x, y)
price := 99_900
applyDiscount(&price, 15)
applyDiscount(nil, 15) // не паникует
fmt.Println(price)
a, b := 8.0, 9.0
avg, n := averageRated([]*float64{&a, nil, &b, nil})
fmt.Printf("%.1f по %d оценкам\n", avg, n)
}2 1
84915
8.5 по 2 оценкамТренировка: предскажи вывод
package main
import "fmt"
func update(p *int) {
*p = 10
p = nil
}
func main() {
n := 1
p := &n
update(p)
fmt.Println(n, p == nil)
}самопроверкаОтвет
10 falseУказатель тоже передаётся по значению: функция получает копию адреса. Запись через *p меняет n, а p = nil обнуляет только локальную копию указателя.
Проверь себя
вопросЧто делают операторы & и *?
&x — берёт адрес переменной x. *p — разыменовывает указатель p: читает или меняет значение по адресу.
вопросКакой тип у &x, если x — float64?
*float64.
вопросКак функции изменить переменную вызывающего кода?
Принять указатель (func f(p *T)), а вызывающий передаёт адрес: f(&x). Внутри — *p = ….
вопросЧто будет при разыменовании nil-указателя?
Паника: invalid memory address or nil pointer dereference. Перед разыменованием проверяют p != nil.
вопросБезопасно ли вернуть из функции указатель на локальную переменную?
Да. Escape analysis заметит, что переменная «убегает» из функции, и разместит её в куче; GC удалит её, когда указателей не останется.
вопросНужно ли передавать мапу в функцию по указателю, чтобы добавить элемент?
Нет. Мапа содержит указатель на данные внутри, изменения видны снаружи и так.
вопросЗачем использовать *float64 вместо float64 для оценки пользователя?
Чтобы отличать «оценки нет» (nil) от «оценка 0».
Ключевые выводы
- 📍 Указатель — адрес:
&берёт адрес,*читает и меняет значение по адресу. - ✏️ Через указатель функция меняет оригинал и не копирует большие структуры.
- 🪄 К полям структуры через указатель обращаются просто через точку — Go разыменует сам.
- 💥
nil-указатель разыменовывать нельзя — проверяй перед использованием. - 🏠 Указатель на локальную переменную можно вернуть: escape analysis перенесёт её в кучу.
- 🔗 Слайсы, мапы и каналы уже ссылочные — указатель на них обычно не нужен.
