Если в замыкании захватить структуру она будет захвачена в стеке или в куче?

Захват структур в замыканиях Swift

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

Поведение по умолчанию

По умолчанию Swift использует захват по значению (value capture). При захвате структуры создается ее копия, которая хранится вместе с замыканием:

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

func createClosure() -> () -> Void {
    var point = Point(x: 10, y: 20) // Создается в стеке функции
    
    let closure = {
        point.x += 1 // Захватывается копия структуры
        print("Point: (\(point.x), \(point.y))")
    }
    
    return closure
}

В этом примере при создании замыкания происходит:

1. Создание копии структуры Point
2. Эта копия хранится в контексте захвата замыкания

Критическое различие: где размещается контекст захвата

Вот ключевой момент: сама структура хранится как значение, но контекст захвата может находиться в куче:

1. Неэскейпирующие замыкания (non-escaping) - контекст захвата остается в стеке
2. Эскейпирующие замыкания (escaping) - контекст захвата перемещается в кучу

class Container {
    var closure: (() -> Void)?
    
    func storeClosure() {
        var counter = 0 // Int - структура
        
        // Замыкание становится escaping, так как сохраняется
        self.closure = {
            counter += 1 // counter захватывается и хранится в куче
            print("Counter: \(counter)")
        }
    }
}

Что происходит при захвате escaping-замыканием

Когда замыкание должно пережить область видимости, в которой оно создано:

import Foundation

func createEscapingClosure() -> () -> Void {
    var data = Data() // Data - структура
    
    return {
        // 1. Swift создает контекст захвата в куче
        // 2. Копирует структуру data в этот контекст
        // 3. Для mutable захвата использует reference counting
        data.append(contentsOf: [1, 2, 3])
        print("Data size: \(data.count)")
    }
}

Как Swift реализует это на практике

Под капотом Swift использует механизм захвата с подсчетом ссылок:

// Примерный эквивалент того, что происходит (упрощенно):
class CaptureBox<T> {
    var value: T
    init(_ value: T) { self.value = value }
}

func demonstration() -> () -> Void {
    var point = Point(x: 1, y: 2)
    
    // Swift неявно создает нечто подобное:
    let box = CaptureBox(point) // Box в куче, содержит копию Point
    
    return {
        box.value.x += 1 // Работаем через box
    }
}

Ключевые выводы:

1. Сама структура всегда передается по значению - создается копия
2. Для локальных неэскейпирующих замыканий - контекст захвата остается в стеке
3. Для эскейпирующих замыканий - контекст захвата размещается в куче
4. Мутабельный захват требует индирекции, даже для структур
5. Swift автоматически управляет этим через компиляторные оптимизации

Проверка на практике

Вы можете убедиться в этом, используя Mirror или инструменты профилирования:

func testCaptureLocation() {
    var largeStruct = Array(repeating: 0, count: 1000) // Большая структура
    
    withExtendedLifetime(largeStruct) {
        let closure = { [largeStruct] in
            // Захваченная копия
            print("Captured array count: \(largeStruct.count)")
        }
        
        // Если замыкание escaping, его контекст будет в куче
        // Это можно проверить через Memory Graph Debugger
    }
}

Итог: Структура захватывается по значению (копируется), но если замыкание является эскейпирующим, то контекст, содержащий эту копию, размещается в куче. Для неэскейпирующих замыканий все остается в стеке. Это фундаментальный аспект модели памяти Swift, который обеспечивает баланс между производительностью и безопасностью.