Какие знаешь нюансы работы со стеком?

Нюансы работы со стеком (Call Stack) в Swift

Что такое стек (Stack)

Call Stack — это область памяти, где хранятся локальные переменные функций, параметры и возвращаемые значения. Он работает по принципу LIFO (Last In, First Out).

┌─────────────────────────┐
│  main()                 │  ← Base
├─────────────────────────┤
│  functionA(x: 5)        │
├─────────────────────────┤
│  functionB()            │  ← Top (последний вызов)
└─────────────────────────┘

Основные нюансы

1. Stack Overflow — переполнение стека

// ❌ Бесконечная рекурсия
func infiniteRecursion() {
    infiniteRecursion()  // Каждый вызов добавляет frame в стек
}
// Fatal error: stack overflow

// ✅ Правильная рекурсия с условием выхода
func factorial(_ n: Int) -> Int {
    if n <= 1 { return 1 }  // Base case
    return n * factorial(n - 1)
}

// Стек:
// factorial(4)
//  └─ factorial(3)
//      └─ factorial(2)
//          └─ factorial(1)  ← Base case, начинаем возвращаться

2. Размер stack frame для функции

// Маленький frame (несколько локальных переменных)
func smallFunction() {
    let a: Int = 5      // 8 байт
    let b: String = "hello"  // Reference (8 байт) + данные в heap
    let c: Bool = true   // 1 байт
    // Total: примерно 25 байт в стеке
}

// Большой frame (множество локальных переменных)
func largeFunction() {
    var largeArray = [Int](repeating: 0, count: 1000)  // Reference + data в heap
    var manyVariables: [Int] = (0...1000).map { $0 }   // Reference + data в heap
    // Структура может быть большой, если это value type!
}

// Проблема: большие структуры в стеке
struct HugeStruct {  // 1MB данных
    var data: [Int] = Array(0..<262144)  // Большой массив
}

func passBigStruct(_ s: HugeStruct) {
    // s копируется в stack frame (1MB!)
    // Может привести к stack overflow
}

// Решение: передавай reference
class HugeClass {
    var data: [Int] = Array(0..<262144)
}

func passBigClass(_ c: HugeClass) {
    // c — только reference (8 байт)
}

3. Value Type при передаче в функцию

// Struct (value type) копируется
struct Point {
    var x: Int
    var y: Int
}

func modifyPoint(_ p: Point) {  // p копируется в stack frame
    var copy = p  // Еще одна копия
    copy.x = 10
}

let point = Point(x: 0, y: 0)
modifyPoint(point)  // Копируется в функцию
// Оригинальный point не изменился

// Если передать inout:
func modifyPointInPlace(_ p: inout Point) {
    p.x = 10  // Изменяет оригинальный
}

var mutablePoint = Point(x: 0, y: 0)
modifyPointInPlace(&mutablePoint)  // Не копирует
print(mutablePoint.x)  // 10

4. Stack vs Heap для разных типов

// Находятся В СТЕКЕ:
let int = 42              // Значение в стеке
let bool = true           // Значение в стеке
let tuple = (1, 2)        // Значение в стеке
let point = Point(0, 0)   // Значение в стеке

// Находятся В HEAP (reference в стеке):
let array = [1, 2, 3]     // Reference в стеке, данные в heap
let dict = ["a": 1]       // Reference в стеке, данные в heap
let obj = MyClass()       // Reference в стеке, объект в heap
let string = "hello"      // Reference в стеке, данные в heap

// Смешанное:
struct User {
    var id: Int          // В стеке (часть структуры)
    var name: String     // Reference в стеке, данные в heap
    var posts: [Post]    // Reference в стеке, данные в heap
}

5. Tail Recursion Optimization (TCO)

// ❌ Обычная рекурсия (не оптимизируется в Swift)
func sum(_ numbers: [Int], _ result: Int = 0, _ index: Int = 0) -> Int {
    guard index < numbers.count else { return result }
    return sum(numbers, result + numbers[index], index + 1)
    // Хвостовой вызов, но Swift не оптимизирует
}
// Каждый вызов добавляет frame в стек
sum(Array(1...10000))  // Stack overflow

// ✅ Итеративный подход
func iterativeSum(_ numbers: [Int]) -> Int {
    var result = 0
    for num in numbers {
        result += num
    }
    return result  // Один frame в стеке
}

// ✅ Или используй reduce
let result = numbers.reduce(0, +)  // Оптимизировано

6. Escaping Closures и захват в heap

// Non-escaping closure (по умолчанию)
func withNonescaping(_ closure: () -> Void) {
    closure()  // Вызывается сразу
    // closure удаляется когда функция заканчивается
}

// Escaping closure (живет дольше)
func withEscaping(_ closure: @escaping () -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        closure()  // Вызывается позже
        // closure должен быть в heap, потому что стек frame был удален
    }
}

// Проблема: захват переменных
var counter = 0
withEscaping {
    counter += 1  // Захватывает counter
}
// closure должен сохранить counter где-то (обычно в heap)

7. Локальные переменные и область видимости

func demonstrateScoping() {
    let outer = 10
    
    {
        let inner = 20
        print(outer)  // Доступен (захвачен closure)
        print(inner)  // Доступен
    }()
    
    print(inner)  // ❌ Ошибка компиляции (не в стеке)
}

// После выхода из блока inner удаляется со стека
// outer остается в стеке до конца функции

8. Ошибки при работе со стеком

// ❌ Ошибка 1: Возврат reference на локальную переменную
func dangerousPointer() -> UnsafePointer<Int> {
    var local = 42
    return withUnsafePointer(to: &local) { $0 }
    // local удаляется со стека!
    // UnsafePointer теперь указывает на мусор
}

// ❌ Ошибка 2: Use-after-free
var pointer: UnsafePointer<Int>?
do {
    var value = 10
    pointer = withUnsafePointer(to: &value) { $0 }
}
// value удалена со стека
print(pointer!.pointee)  // Undefined behavior!

// ✅ Правильно: используй heap для такого
var pointer: UnsafeMutablePointer<Int>? = .allocate(capacity: 1)
pointer?.pointee = 42
print(pointer!.pointee)  // 42
pointer?.deallocate()

9. Оптимизация: избегай ненужного копирования

// ❌ Плохо: копирование struct
func processLargeStruct(_ s: LargeStruct) {  // Копируется
    let copy = s  // Еще одна копия!
    // Много копий в стеке
}

// ✅ Хорошо: использование inout
func processLargeStructEfficiently(_ s: inout LargeStruct) {
    // Нет копирования, прямой доступ
}

// ✅ Или используй reference
func processViaClass(_ c: LargeClass) {
    // Только reference в стеке (8 байт)
}

10. Compiler optimizations

// Swift может оптимизировать копирование
struct OptimizedStruct {
    var data: [Int]
}

var s1 = OptimizedStruct(data: [1, 2, 3])
var s2 = s1  // Может не копироваться (CoW)
s2.data.append(4)  // Копируется только здесь

// В отличие от:
var s3 = s1
var s4 = s3
var s5 = s4
// Swift может оптимизировать цепочку

Практические советы

// 1. Избегай глубокую рекурсию
func recursion(_ n: Int) -> Int {
    guard n > 0 else { return 0 }
    return n + recursion(n - 1)  // Вызовет stack overflow на большом n
}
// Решение: используй цикл или trampolining

// 2. Будь осторожен с размером value types
struct SmallStruct {
    let a: Int
    let b: Int
}
// Безопасно в стеке

struct HugeStruct {
    let largeArray: [Int]  // Данные в heap, но reference большой
}
// Может быть проблемой, если много копирований

// 3. Используй inout для больших структур
func modify(_ s: inout LargeStruct) {
    // Нет копирования
}

// 4. Профилируй с Instruments
// System Trace → показывает stack usage
// Memory Graph → показывает references

Выводы

• Stack — быстро, ограничено по размеру (обычно 1-8MB)
• Heap — медленнее, неограниченный размер
• Value types живут в стеке (или как reference к heap)
• Reference types живут в heap
• Recursion может переполнить стек
• Copy-on-Write оптимизирует копирование структур
• Escaped closures должны захватывать в heap