Если используем mutating создается копия или изменяется текущий экземпляр?

Вопрос о поведении mutating в Swift

Когда мы объявляем метод структуры или перечисления с ключевым словом mutating, происходит следующее:

Основной принцип

Swift-структуры и перечисления являются значимыми типами (value types). По умолчанию их свойства нельзя изменять изнутри методов, поскольку методы работают с неизменяемой копией экземпляра. Ключевое слово mutating разрешает модификацию свойств, но при этом возникает важный нюанс с копированием.

Что происходит на самом деле?

mutating метод изменяет текущий экземпляр, но при этом для внешнего наблюдателя (кода, который вызвал метод) создается впечатление, что изменилась именно оригинальная переменная. Под капотом Swift использует оптимизацию, известную как copy-on-write (копирование при записи).

Рассмотрим пример:

struct Point {
    var x: Int
    var y: Int
    
    mutating func moveBy(x deltaX: Int, y deltaY: Int) {
        x += deltaX
        y += deltaY
    }
}

var point = Point(x: 10, y: 20)
point.moveBy(x: 5, y: 5) // x = 15, y = 25

Механизм работы

1. При вызове mutating метода:

   • Если переменная, хранящая структуру, не имеет других ссылок (unique reference), Swift изменяет существующий экземпляр на месте (in-place modification)
   • Если на структуру есть несколько ссылок (например, она присвоена другой переменной или передана в функцию), то создается копия, которая затем изменяется

2. Пример с несколькими ссылками:

var original = Point(x: 10, y: 20)
var copy = original // Пока что копирования в памяти не происходит (только логическая копия)

original.moveBy(x: 5, y: 5) 
// В этот момент создается физическая копия для original
// original становится Point(x: 15, y: 25)
// copy остается Point(x: 10, y: 20)

Важные детали

• Для оптимизации компилятор Swift анализирует время жизни объектов и может избежать лишнего копирования, если уверен, что структура уникальна
• inout параметры работают аналогично: при передаче структуры как inout аргумента, после выполнения функции измененное значение копируется обратно
• Отличие от классов: классы (ссылочные типы) не требуют mutating, так как методы всегда работают с оригинальным экземпляром

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

struct Stack<Element> {
    private var elements: [Element] = []
    
    // Без mutating нельзя изменить elements
    mutating func push(_ element: Element) {
        elements.append(element)
    }
    
    mutating func pop() -> Element? {
        return elements.popLast()
    }
}

var stack = Stack<Int>()
stack.push(1) // Изменяется stack.elements
stack.push(2)

// Если сделать так:
var anotherStack = stack
anotherStack.push(3)
// Теперь stack и anotherStack имеют разные массивы элементов
// благодаря механизму copy-on-write

Вывод

Ключевое слово mutating не всегда создает копию, но всегда гарантирует, что изменение структуры будет безопасным с точки зрения семантики значимых типов. Фактическое копирование происходит по необходимости, когда структура разделяется между несколькими переменными. Это одна из мощных оптимизаций Swift, которая сочетает безопасность значимых типов с производительностью.