Где хранится Strong ссылка?

Отличный вопрос, который затрагивает самую суть механизма управления памятью в Swift — Automatic Reference Counting (ARC). Прямой и короткий ответ: Strong-ссылка (сильная ссылка) хранится в стеке вызовов или в куче (heap), как часть экземпляра класса или замыкания, который ее удерживает.

Однако, чтобы ответ был полным и полезным для собеседования, необходимо раскрыть контекст. Сильная ссылка — это не изолированный объект, который где-то «лежит», а тип связи между экземпляром и ссылкой на него. Место её «хранения» определяется тем, где находится сама переменная или свойство.

Давайте разберем детально.

1. Суть Strong-ссылки

В Swift по умолчанию все ссылки на экземпляры классов и захваты в замыканиях являются сильными (strong). Это означает, что ARC увеличивает счетчик сильных ссылок (strong reference count) на единицу для целевого объекта. Пока этот счетчик больше нуля, объект остается в памяти. Это базовый механизм владения.

class Person {
    let name: String
    init(name: String) { self.name = name }
}

// В этот момент:
// 1. В стеке (для локальной переменной `ref`) выделяется память под саму ссылку (указатель).
// 2. В куче создается экземпляр класса Person.
// 3. В структуре объекта Person в куче (в его заголовке) ARC счетчик strong references увеличивается с 0 до 1.
// СИЛЬНАЯ ССЫЛКА — это сама связь: переменная `ref` теперь владеет объектом.
var ref: Person? = Person(name: "Alice") // Strong reference count = 1

2. Где физически располагаются переменные, содержащие Strong-ссылки?

Место хранения ссылки зависит от контекста объявления переменной:

• В стеке вызовов (Stack):

    *   **Локальные переменные** внутри функций, методов, замыканий.
    *   **Параметры функций**, передаваемые по значению (но сам параметр — ссылка, живущая в стеке).
    *   Стек работает по принципу LIFO, очень быстр. Ссылка уничтожается автоматически при выходе из области видимости (scope), что вызывает уменьшение счетчика ARC.

```swift
func createPerson() {
    let localPerson = Person(name: "Bob") // Strong-ссылка `localPerson` размещена в стеке.
    // ... использование объекта
} // Выход из области видимости. Ссылка `localPerson` из стека уничтожается,
  // strong reference count уменьшается, объект может быть деаллоцирован.
```

• В куче (Heap):

    *   **Свойства-ссылки других классов.** Это самый частый источник сильных ссылок и потенциальных циклов удержания (retain cycles).
    *   **Захваченные значения в замыканиях** по умолчанию (`[self]`).

```swift
class Apartment {
    var tenant: Person? // Это свойство — strong-ссылка. Оно размещено В КУЧЕ,
                        // как часть экземпляра класса Apartment.
    init(tenant: Person?) {
        self.tenant = tenant // При присвоении strong reference count объекта Person увеличивается.
    }
}

let john = Person(name: "John") // Сильная ссылка из стека `john`
let unit4A = Apartment(tenant: john) // Теперь ДВЕ сильные ссылки на один объект Person:
                                     // 1. Из стека (`john`).
                                     // 2. Из кучи (свойство `tenant` объекта `unit4A`).
```

• В глобальной/статической памяти:

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

```swift
class AppSettings {
    static let shared = Settings() // Strong-ссылка в статической памяти.
}
```

3. Почему это важно? Retain Cycles

Понимание, что strong-ссылка — это связь владения, а не место, критически важно для предотвращения циклов сильных ссылок (strong reference cycles). Проблема возникает, когда два объекта в куче имеют сильные ссылки друг на друга. Их счетчики никогда не опустятся до нуля, что приводит к утечке памяти (memory leak).

class Person {
    var apartment: Apartment? // Strong ref
}
class Apartment {
    var tenant: Person? // Strong ref
}

var john: Person? = Person(name: "John")
var unit4A: Apartment? = Apartment(tenant: nil)

john!.apartment = unit4A // Person strong -> Apartment
unit4A!.tenant = john    // Apartment strong -> Person. ЦИКЛ!

john = nil    // Ссылка из стека уничтожена, но счетчик объекта Person = 1 (удерживается unit4A.tenant).
unit4A = nil  // Ссылка из стека уничтожена, но счетчик объекта Apartment = 1 (удерживается john.apartment).
// ОБА ОБЪЕКТА ВИСЯТ В ПАМЯТИ БЕЗ ВОЗМОЖНОСТИ ДОСТУПА.

Решение — использование weak (слабых) или unowned (бесхозных) ссылок, которые не увеличивают счетчик сильных ссылок и позволяют его обнулить.

Итог для собеседования

Strong-ссылка — это связь владения по умолчанию в ARC. Физически указатель (сама ссылка) хранится там же, где и объявленная переменная или свойство: в стеке для локальных переменных, в куче для свойств классов и захватов замыканий, в статической памяти для глобальных и static-переменных. Ключевая задача strong-ссылки — удерживать объект в памяти, увеличивая его счетчик ссылок. Понимание этого механизма является фундаментальным для написания корректного, не подверженного утечкам памяти кода на Swift.