В чем разиница между копированием массива и структуры?

Копирование массива и структуры в Swift

Основное различие между копированием массива (Array) и структуры (struct) в Swift заключается в поведении их семантики копирования и механизмах оптимизации, которые компилятор применяет "под капотом".

Семантика копирования

Для структур (value types)

Структуры в Swift являются значимыми типами (value types), что означает, что при присваивании или передаче в качестве параметра функции создается полная независимая копия всех данных:

struct Point {
    var x: Int
    var y: Int
}

var point1 = Point(x: 10, y: 20)
var point2 = point1 // Создается полная копия

point2.x = 30
print(point1.x) // 10 - оригинал не изменился
print(point2.x) // 30 - изменилась только копия

Для массивов (reference types с value semantics)

Массивы в Swift реализованы как структуры, но с использованием механизма Copy-on-Write (CoW). Это оптимизация, которая откладывает фактическое копирование до момента модификации:

var array1 = [1, 2, 3, 4, 5]
var array2 = array1 // Пока что обе переменные ссылаются на одни данные

// Доступ только для чтения - копирование не происходит
print("array1[0]: \(array1[0])") // 1
print("array2[0]: \(array2[0])") // 1

// Модификация массива - ТОЛЬКО СЕЙЧАС происходит реальное копирование
array2.append(6)

print(array1) // [1, 2, 3, 4, 5] - оригинал не изменился
print(array2) // [1, 2, 3, 4, 5, 6] - изменилась копия

Ключевые различия

1. Момент копирования

• Структуры: Копирование происходит немедленно при присваивании
• Массивы: Копирование откладывается до первой модификации (CoW)

2. Производительность

• Для маленьких структур немедленное копирование обычно дешевле, чем CoW
• Для больших массивов CoW значительно эффективнее, так как избегает ненужных копирований

3. Реализация "под капотом"

Массивы используют буфер с подсчетом ссылок, что позволяет реализовать CoW:

// Упрощенная концепция реализации
class ArrayBuffer<T> {
    var storage: [T]
    var refCount: Int
    
    init(_ elements: [T]) {
        self.storage = elements
        self.refCount = 1
    }
    
    func makeUniqueCopyIfNeeded() {
        if refCount > 1 {
            // Создаем реальную копию
            // ...
            refCount = 1
        }
    }
}

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

Когда использовать CoW оптимально:

• Большие коллекции данных (тысячи элементов)
• Частое присваивание без модификации
• Сценарии "чтения преобладают над записью"

Когда обычная семантика value types лучше:

• Небольшие структуры (несколько примитивных полей)
• Частые модификации после копирования
• Требуется детерминированное поведение

Пример с вложенными структурами

struct Person {
    var name: String
    var age: Int
}

var people1 = [Person(name: "Alice", age: 25), Person(name: "Bob", age: 30)]
var people2 = people1 // CoW: реального копирования еще нет

// Изменяем структуру внутри массива
people2[0].age = 26 // CoW срабатывает здесь

print(people1[0].age) // 25 - оригинал не изменился

Важные нюансы

1. Строки (String) также используют CoW, как и массивы
2. Словари (Dictionary) и множества (Set) также реализуют CoW
3. Не все коллекции используют CoW - например, NSArray в Foundation является reference type

Заключение

Различие в копировании массивов и структур демонстрирует баланс, который Swift находит между безопасностью value semantics и производительностью. Структуры обеспечивают простое и предсказуемое поведение с немедленным копированием, в то время как массивы (и другие коллекции) используют оптимизацию Copy-on-Write для эффективной работы с большими объемами данных. Это делает Swift эффективным как для высокоуровневого абстрактного кода, так и для производительных вычислений.