Куда указывает указатель слайса?

Анатомия слайса в Go и куда указывает его указатель

В Go слайс (slice) — это не просто указатель на массив, а сложная структура данных, состоящая из трех компонентов, которая описывается под капотом как структура runtime.slice. Чтобы понять, куда указывает указатель слайса, нужно разобрать его внутреннее устройство.

Внутреннее представление слайса

Слайс является дескриптором (descriptor) сегмента массива. На низком уровне он представлен следующей структурой (примерное представление, аналогичное reflect.SliceHeader):

type slice struct {
    array unsafe.Pointer // Указатель на массив
    len   int            // Длина слайса
    cap   int            // Ёмкость слайса
}

Указатель слайса — это именно поле array внутри этой структуры. Он указывает на первый элемент базового массива, к которому обращается слайс.

На что именно указывает указатель array?

Указатель array всегда указывает на конкретный элемент в памяти, с которого начинается видимая часть слайса в базовом массиве. Это может быть:

• Первый элемент массива (если слайс создан с нулевого индекса)
• Любой другой элемент массива (если слайс создан как срез существующего массива или другого слайса)

Пример, демонстрирующий это поведение:

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // Создаем массив
    arr := [5]int{10, 20, 30, 40, 50}
    
    // Создаем слайс, указывающий на весь массив
    slice1 := arr[:]
    // Указатель указывает на первый элемент массива (arr[0])
    fmt.Printf("slice1: %v, указатель: %p\n", slice1, &slice1[0])
    
    // Создаем слайс, начиная с индекса 2
    slice2 := arr[2:]
    // Указатель теперь указывает на arr[2]
    fmt.Printf("slice2: %v, указатель: %p\n", slice2, &slice2[0])
    
    // Докажем, что указатели отличаются ровно на 2 элемента
    ptr1 := unsafe.Pointer(&slice1[0])
    ptr2 := unsafe.Pointer(&slice2[0])
    // Разница в байтах (каждый int занимает 8 байт на 64-битной системе)
    diff := uintptr(ptr2) - uintptr(ptr1)
    fmt.Printf("Разница между указателями: %d байт\n", diff)
}

Ключевые особенности указателя слайса

1. Слайс — это значение, содержащее указатель
   Когда вы передаете слайс в функцию, копируется дескриптор слайса (включая указатель array, len и cap), но не базовый массив. Поэтому изменения элементов слайса внутри функции видны снаружи.

2. Несколько слайсов могут указывать на один массив
   Это может приводить к неожиданным side-эффектам:

package main

import "fmt"

func main() {
    original := []int{1, 2, 3, 4, 5}
    slice1 := original[1:4] // [2, 3, 4]
    slice2 := original[2:5] // [3, 4, 5]
    
    // Изменяем элемент через slice1
    slice1[1] = 99
    
    // Изменение видно в обоих слайсах и в оригинальном массиве
    fmt.Println("slice1:", slice1) // [2, 99, 4]
    fmt.Println("slice2:", slice2) // [99, 4, 5]
    fmt.Println("original:", original) // [1, 2, 99, 4, 5]
}

1. Изменение указателя при реаллокации
   При операциях, превышающих capacity, происходит выделение нового массива, и указатель array начинает указывать на новый участок памяти:

package main

import "fmt"

func main() {
    slice := make([]int, 3, 3)
    slice[0], slice[1], slice[2] = 1, 2, 3
    
    fmt.Printf("До append: указатель = %p, len = %d, cap = %d\n", 
        &slice[0], len(slice), cap(slice))
    
    // Превышаем capacity
    slice = append(slice, 4)
    
    fmt.Printf("После append: указатель = %p, len = %d, cap = %d\n", 
        &slice[0], len(slice), cap(slice))
    // Указатель изменился!
}

Практические следствия

• Сравнение указателей слайсов имеет ограниченную полезность, так как слайсы с одинаковыми данными могут быть в разных дескрипторах
• Нулевой слайс (nil slice) имеет указатель array = nil, len = 0, cap = 0
• Пустой слайс (empty slice, созданный через make([]int, 0)) может иметь ненулевой указатель на фиктивный массив

Заключение

Указатель слайса в Go — это указатель на первый элемент сегмента базового массива, который хранится внутри дескриптора слайса. Понимание этого механизма критически важно для:

• Эффективной работы с памятью
• Предотвращения неожиданных мутаций данных
• Понимания поведения append и реаллокаций
• Оптимизации производительности при работе с большими наборами данных

Это фундаментальное знание отличает начинающего Go-разработчика от опытного, так как позволяет предсказывать поведение программы и избегать распространенных ошибок, связанных с совместным использованием памяти разными слайсами.