Як і багато інших мов, Go має вказівники.
Якщо ми тільки починаємо знайомитися з вказівниками, вони можуть здаватися трохи загадковими, але щойно ми до них звикнемо, вони стануть цілком зрозумілими.
Це надзвичайно важлива частина Go, тож варто приділити час, щоб справді їх зрозуміти.
Перш ніж заглиблюватися в деталі, варто зрозуміти, для чого потрібні вказівники.
Вказівники дають змогу ділитися памʼяттю з іншими частинами нашої програми, і це корисно з двох основних причин:
- Коли ми маємо великі обсяги даних, створення копій для передавання між функціями є вкрай неефективним.
Натомість, передаючи місце в памʼяті, де зберігаються дані, ми можемо суттєво зменшити обсяг ресурсів, які споживають наші програми.
- Передаючи вказівники між функціями, ми можемо безпосередньо звертатися до єдиної копії даних і змінювати її, а отже, будь-які зміни, зроблені однією функцією, одразу стають видимими для інших частин програми, коли функція завершується.
Змінні та памʼять
Уявімо, що ми маємо звичайну змінну цілого типу a:
var a int
Коли ми оголошуємо змінну, Go має знайти місце в памʼяті, щоб зберегти її значення.
Здебільшого це від нас приховано: коли нам потрібно дістати значення, що зберігається в цій ділянці памʼяті, ми можемо просто звернутися до нього за іменем змінної.
Наприклад, коли ми пишемо a + 2, ми фактично дістаємо значення, збережене в памʼяті, повʼязаній зі змінною a, і додаємо до нього 2.
Так само, коли нам потрібно змінити значення в ділянці памʼяті a, ми можемо скористатися іменем змінної, щоб виконати присвоєння:
a = 3
Ділянка памʼяті, повʼязана з a, тепер зберігатиме значення 3.
Вказівники
Хоча змінні дають нам змогу посилатися на значення в памʼяті, іноді корисно знати адресу памʼяті, на яку вказує змінна. Вказівники зберігають адреси памʼяті цих значень.
Щоб оголосити змінну типу вказівника, потрібно поставити зірочку перед базовим типом:
var p *int // 'p' contains the memory address of an integer
Тут ми оголошуємо змінну p типу «вказівник на int» (*int).
Це означає, що p зберігатиме адресу памʼяті цілого числа.
Нульовим значенням вказівників є nil, бо вказівник зі значенням nil не зберігає жодної адреси памʼяті.
Отримання вказівника на змінну
Щоб знайти адресу памʼяті значення змінної, ми можемо скористатися оператором &.
Наприклад, якщо ми хочемо знайти адресу памʼяті змінної a і зберегти її у вказівнику p, ми можемо зробити так:
var a int
a = 2
var p *int
p = &a // the variable 'p' contains the memory address of 'a'
Коли ми маємо вказівник, нам може знадобитися дізнатися значення, збережене за адресою памʼяті, яку представляє вказівник.
Це можна зробити за допомогою оператора *:
var a int
a = 2
var p *int
p = &a // the variable 'p' contains the memory address of 'a'
var b int
b = *p // b == 2
Операція *p дістає значення, збережене за адресою памʼяті, що міститься в p.
Цю операцію часто називають «розіменуванням».
Ми також можемо скористатися оператором розіменування, щоб присвоїти нове значення за адресою памʼяті, на яку посилається вказівник:
var a int // declare int variable 'a'
a = 2 // assign 'a' the value of 2
var pa *int
pa = &a // 'pa' now contains to the memory address of 'a'
*pa = *pa + 2 // increment by 2 the value at memory address 'pa'
fmt.Println(a) // Output: 4
// 'a' will have the new value that was changed via the pointer!
Присвоєння до *pa змінить значення, збережене за адресою памʼяті, яку містить pa.
Оскільки pa містить адресу памʼяті змінної a, присвоюючи до *pa, ми фактично змінюємо значення a!
Але застереження: перш ніж розіменовувати вказівник, завжди перевіряймо, чи він не nil.
Розіменування вказівника зі значенням nil призведе до аварійного завершення програми під час виконання!
var p *int // p is nil initially
fmt.Println(*p)
// panic: runtime error: invalid memory address or nil pointer dereference
Вказівники на структури
Досі ми бачили лише вказівники на прості значення.
Ми також можемо створювати вказівники на структури:
type Person struct {
Name string
Age int
}
var peter Person
peter = Person{Name: "Peter", Age: 22}
var p *Person
p = &peter
Ми могли б також створити нову Person і одразу зберегти вказівник на неї:
var p *Person
p = &Person{Name: "Peter", Age: 22}
Коли ми маємо вказівник на структуру, нам не потрібно розіменовувати його, перш ніж звертатися до одного з полів:
var p *Person
p = &Person{Name: "Peter", Age: 22}
fmt.Println(p.Name) // Output: "Peter"
// Go automatically dereferences 'p' to allow
// access to the 'Name' field
Зрізи та мапи вже є вказівниками
Зрізи та мапи належать до особливих типів, бо вже мають вказівники у своїй реалізації.
Це означає, що здебільшого нам не потрібно створювати вказівники на ці типи, щоб ділитися адресою памʼяті їхніх значень.
Уявімо, що ми маємо функцію, яка збільшує значення ключа в мапі:
func incrementPeterAge(m map[string]int) {
m["Peter"] += 1
}
Якщо ми створимо мапу й викличемо цю функцію, зміни, які функція внесла до мапи, збережуться після її завершення.
Таку саму поведінку ми отримали б, якби використовували вказівник, але звернімо увагу, що в цьому прикладі ми не використовуємо ні взяття адреси, ні розіменування, ні будь-який інший синтаксис вказівників:
ages := map[string]int{
"Peter": 21
}
incrementPeterAge(ages)
fmt.Println(ages)
// Output: map[Peter:22]
// The changes the function 'incrementPeterAge' made to the map are visible after the function ends!
Те саме стосується зміни наявного елемента у зрізі.
Однак дії, що повертають новий зріз, як-от append, це особливий випадок, і вони можуть не змінити зріз за межами функції.
Це повʼязано з тим, як зрізи працюють усередині, але ми не розглядатимемо це докладно в цій вправі, бо це складніша тема.
Якщо нам справді цікаво, можна прочитати більше про це в Go Blog: Mechanics of 'append'
Навчальна вправа
