Краткий ответ

Для структуры константная привязка запрещает изменять её хранимые свойства и вызывать методы, помеченные mutating. Для класса константной является сама ссылка: её нельзя переназначить на другой экземпляр, но изменяемые свойства объекта по этой ссылке менять можно.

Иными словами, let ограничивает значение структуры целиком, а для класса — только направление ссылки. Это следствие различия между семантикой значения и семантикой ссылки.

Исторический контекст

Swift сочетает структуры со значимой семантикой и классы со ссылочной семантикой. Такой подход позволяет выбирать модель владения данными: структуры удобны для независимых значений, а классы — для совместно изменяемых объектов с идентичностью.

Ключевое правило let должно работать в обеих моделях, но объект класса и сама ссылка на него — разные сущности. Поэтому константность ссылки не означает автоматическую неизменяемость объекта, на который она указывает.

Постановка проблемы

Ошибка возникает, когда разработчик переносит интуицию от структуры к классу. Он может ожидать, что константный экземпляр класса полностью защищён от изменений, хотя другой код, имеющий ссылку на тот же объект, способен наблюдать или выполнять эти изменения.

Обратная ошибка тоже опасна: константная структура не допускает изменения даже тогда, когда изменение кажется локальным. Неверный выбор модели приводит к неожиданным ограничениям компилятора либо к неявному совместному состоянию.

Подробное решение

У структуры переменная хранит само значение. Изменение её свойства означает изменение значения, поэтому константная структура не может быть изменена. Вызов mutating-метода также запрещён, поскольку такой метод может изменить состояние структуры.

У класса переменная хранит ссылку на объект. Объявление ссылки через let запрещает только переназначение ссылки: нельзя заставить её указывать на другой объект. Если свойство класса объявлено как var, его можно изменить через константную ссылку.

struct Point {
    var x: Int
}

final class Counter {
    var value = 0
}

let point = Point(x: 1)
// point.x = 2              // Ошибка: структура неизменяема

let counter = Counter()
counter.value = 1           // Допустимо: изменён объект
// counter = Counter()      // Ошибка: ссылка-константа

У класса не существует требования помечать обычный метод как mutating: изменение состояния объекта не заменяет сам объект и поэтому не считается изменением ссылки. Однако это не делает операции потокобезопасными и не устраняет необходимость синхронизации при совместном доступе из нескольких потоков.

Константность ссылки также не распространяется на другие ссылки на тот же экземпляр. Чтобы запретить изменение состояния класса через конкретный интерфейс, применяют свойства let, методы без операций изменения или проектируют отдельный доступный только для чтения протокол.

Ситуация из практики

В приложении есть объект кэша, который передаётся нескольким компонентам. Владелец не должен заменить сам кэш во время работы, но компоненты должны добавлять и удалять записи.

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

Выбирают класс, хранящий изменяемое состояние, и константную ссылку на него. Компоненты могут менять записи, но не могут переназначить ссылку владельца; при этом для многопоточного доступа отдельно добавляют синхронизацию или изолируют объект средствами Swift Concurrency.

Что кандидаты часто упускают

Запрещает ли let для класса изменение его свойств?

Нет, если свойства объявлены как var. let фиксирует ссылку, а не состояние объекта. Изменение всё равно будет видно через все ссылки на тот же экземпляр.

Можно ли изменить свойство структуры через константную ссылку на вложенный объект класса?

Само свойство структуры изменить нельзя, но объект класса, уже сохранённый внутри этого свойства, может быть изменён через доступ к его внутреннему состоянию. Значимое значение структуры содержит ссылку, а не копию объекта; копирование такой структуры не создаёт независимую копию ссылочного объекта.

Делает ли константная ссылка на класс код безопасным для многопоточности?

Нет. Она запрещает переназначение ссылки, но не защищает изменяемое состояние объекта от гонок данных или несогласованных наблюдений. Потокобезопасность требует отдельного механизма: изоляции, синхронизации или проектирования состояния как неизменяемого.