Перейти на PRO

Почему в Swift нет copy-on-write для простых типов вроде Int?

Тип вопроса: Swift Core Вероятность: 10% Категория: IOS Разработчик

Ответ

Copy-on-write (CoW) не реализован для простых типов (Int, Double, Bool и т.д.) из-за соображений производительности, семантики и практической целесообразности.

Технические причины:

  1. Низкая стоимость копирования — простые типы имеют фиксированный небольшой размер:

    • Int, Double: 8 байт
    • Bool: 1 байт
    • Копирование дешевле, чем проверка уникальности ссылки и управление буфером

  2. Накладные расходы CoW — реализация потребовала бы:

    • Хранения счетчика ссылок (+8 байт минимум)
    • Динамической аллокации памяти в куче
    • Проверки уникальности при каждой модификации

  3. Семантика value types — простые типы должны вести себя как независимые значения:

    var a = 42
var b = a  // Мгновенное копирование значения
b = 100    // a остается 42 — ожидаемое поведение

Сравнение с типами, имеющими CoW:

// Array имеет CoW
var array1 = [1, 2, 3, 4, 5]
var array2 = array1          // Нет копирования, общий буфер
array2.append(6)            // ТОЛЬКО СЕЙЧАС происходит копирование
// array1 = [1, 2, 3, 4, 5]
// array2 = [1, 2, 3, 4, 5, 6]

// Int не имеет CoW
var int1 = 100
var int2 = int1             // Копирование происходит сразу
int2 = 200                  // Простое присваивание
// int1 = 100, int2 = 200

Когда CoW имеет смысл:

  • Большие структуры данных (Array, Dictionary, String)
  • Типы с переменным размером
  • Когда копирование дорого (большие буферы)

Вывод: Для простых типов мгновенное копирование эффективнее и проще, чем сложная оптимизация CoW.

Ответ 18+ 🔞

Ну слушай, тут такая история, блядь. Эти придурки из Swift, они не сделали Copy-on-write для простых типов, типа Int или Bool. И знаешь почему? Потому что это было бы, блядь, медленнее, чем просто скопировать!

Представь себе, сука: у тебя есть Int, 8 байт всего, хуй с горы. Скопировать их — это одно движение, пиздец как быстро. А чтобы сделать CoW, надо, блядь:

  1. Запихнуть эту хуйню в кучу.
  2. Создать счётчик ссылок, который сам по себе весит больше, чем твой Int!
  3. При каждой, сука, попытке изменить значение — проверять, один ты владелец или нет.

Это же, ёпта, овердохуища накладных расходов! Зачем, спрашивается? Чтобы «оптимизировать» копирование восьми байт? Да ты охуел?

Вот смотри, как это работает на практике:

var a = 42
var b = a  // Всё, скопировал, поехали. Никаких телодвижений.
b = 100    // Просто присвоил новое значение. a остался 42.

А теперь посмотри на Array, у него-то CoW есть, и это логично:

var array1 = [1, 2, 3, 4, 5] // Большой массив, в жопу копировать дорого
var array2 = array1          // Ха-ха! Не копируем! Делим один буфер на двоих!
array2.append(6)            // А вот тут, сука, собака и порылась! array2 понимает, что он не один такой умный, и делает себе отдельную копию перед изменением.

Видишь разницу? Для массива копирование — это пиздец какой дорогой процесс, а для Int — это дешевле, чем проверить уникальность ссылки.

Семантика, блядь, тоже важна. Простые типы — это как наличные. Ты дал другу сотку — у тебя её нет. Не как с общей ссылкой на бутылку, где можно вдвоём пить, пока один не захочет добавить свой вишнёвый сироп и не поймёт, что бутылка-то общая.

Вывод, блядь: CoW — это хитрая жопа для больших и сложных структур. Для простых чисел — это всё равно что ебаться в сраку через галошу. Бессмысленно и муторно. Просто копируй и не парься.

© ХакСобесов, 2026
support@hacksobesov.com