Что произойдет, если при добавлении элемента в слайс len превысит cap?

Увеличение слайса за пределы его вместимости

Когда при добавлении элемента в слайс в Go его длина (len) превышает вместимость (cap), происходит автоматическое расширение слайса (slice reallocation). Это критический механизм работы динамических массивов в Go, обеспечивающий их гибкость.

Процесс расширения слайса

Что происходит:

1. Создание нового внутреннего массива большего размера в памяти.
2. Копирование всех существующих элементов из старого массива в новый.
3. Присвоение новой ссылки на этот новый массив переменной слайса (сам слайс остается той же структурой, но его внутренний указатель array изменяется).
4. Добавление нового элемента в конце нового массива.

В результате:

• Новая вместимость (cap) становится больше (обычно по определенной формуле).
• Ссылка на старый массив может остаться в других слайсах (если они были созданы из исходного), но основной слайс теперь работает с новым массивом.

Пример и механизм роста

package main

import "fmt"

func main() {
    // Создаем слайс с вместимостью 2
    s := make([]int, 0, 2)
    fmt.Printf("Начальный: len=%d, cap=%d\n", len(s), cap(s))

    s = append(s, 1) // len=1, cap=2
    s = append(s, 2) // len=2, cap=2
    fmt.Printf("Добавили 2 элемента: len=%d, cap=%d\n", len(s), cap(s))

    // Добавляем третий элемент — превышение cap!
    s = append(s, 3)
    fmt.Printf("После превышения cap: len=%d, cap=%d\n", len(s), cap(s))
}

Вывод будет примерно:

Начальный: len=0, cap=2
Добавили 2 элемента: len=2, cap=2
После превышения cap: len=3, cap=4

Алгоритм увеличения вместимости

Go не увеличивает вместимость на фиксированное значение. Алгоритм в стандартной библиотеке (до версии 1.18) обычно работал так:

1. Если новая требуемая вместимость (newCap) больше удвоенной текущей (oldCap), то newCap становится новой требуемой вместимостью.
2. Иначе, если текущая длина (oldLen) меньше 1024, то вместимость удваивается.
3. Если oldLen >= 1024, вместимость увеличивается на oldCap / 4 (25%) до достижения требуемого размера.

С версии Go 1.18 алгоритм был изменен для более плавного роста и меньшего избыточного выделения памяти, но принцип остается: вместимость увеличивается в зависимости от текущего размера.

Ключевые следствия для разработчика

• Производительность: Расширение слайса требует копирования всех элементов, что может быть дорогостоящим для больших слайсов. Это O(n) операция.
• Предварительное выделение: Для оптимизации часто используется предварительное выделение (preallocation) вместимости через make() с заданной cap, если известен ожидаемый размер.
• Изменение ссылки на массив: После расширения слайс ссылается на новый массив. Другие слайсы, полученные из исходного (например, через срез slice[:2]), продолжат использовать старый массив. Это может привести к неожиданному поведению.

original := []int{1, 2, 3}
sliceA := original[:2] // Срез исходного слайса

original = append(original, 4) // Предположим, что вместимость была 3 - произойдет расширение

// sliceA остался ссылаться на старый массив [1, 2, 3]
fmt.Println(original) // [1, 2, 3, 4]
fmt.Println(sliceA)   // [1, 2]

• Управление памятью: Старый массив становится кандидатом на сборку мусора, если на него нет других ссылок.

Практические рекомендации

1. Используйте make([]T, 0, expectedCapacity) для предварительного выделения, если известен или можно приблизительно оценить конечный размер.
2. Для добавления множества элементов используйте append с несколькими аргументами или другим слайсом (append(slice, anotherSlice...)) — это минимизирует потенциальные многократные расширения.
3. Помните о неявном разделении массива между слайсами и возможных изменениях ссылок после append.

Таким образом, превышение вместимости при добавлении — это штатная операция, обеспечивающая динамичность слайсов, но требующая внимания к производительности и семантике работы с памятью.