Closure Capture 완벽 가이드

Q1. 캡쳐(Capture)란 무엇인가?

// 외부 변수 count를 캡쳐
func makeCounter() -> () -> Int {
    var count = 0
    return {
        count += 1    // count를 캡쳐함
        return count
    }
}

let counter = makeCounter()
print(counter())  // 1
print(counter())  // 2
print(counter())  // 3 - count가 계속 살아있음!

Q2. 기본 캡쳐 방식 - 참조 캡쳐

Class 캡쳐 예제

class ABC {
    var t = 12
}

let abc = ABC()
let closure = {
    print(abc.t)  // abc 캡쳐
}

abc.t = 100
closure()  // 100 출력 - 변경된 값 반영

Struct 캡쳐 예제

struct DEF {
    var t = 12
}

var def = DEF()
let closure = {
    print(def.t)  // def 캡쳐
}

def.t = 100
closure()  // 100 출력 - 변경된 값 반영!

Q3. 값 캡쳐 (Capture List)

Struct - 값 캡쳐

struct DEF { var t = 12 }

var def = DEF()
let closure = { [def] in  // 캡쳐 시점의 값 복사
    print(def.t)
}

def.t = 100
closure()  // 12 출력 - 복사본 사용

Class - Capture List의 한계

class ABC { var t = 12 }

let abc = ABC()
let closure = { [abc] in  // 레퍼런스만 복사됨!
    print(abc.t)
}

abc.t = 100
closure()  // 100 출력 - 여전히 원본 참조

Class 값 복사 방법

class ABC { var t = 12 }
let abc = ABC()

// 방법 1: 필요한 프로퍼티만 복사
let closure1 = { [copiedT = abc.t] in
    print(copiedT)  // 캡쳐 시점의 값
}

// 방법 2: 새 인스턴스 생성
let closure2 = { [copied = ABC()] in
    copied.t = abc.t  // 복사본 사용
    print(copied.t)
}

abc.t = 100
closure1()  // 12 출력

요약 테이블

Q4. 클로저의 메모리 구조

Q5. Struct 캡쳐 시 Box 구조

struct DEF { var t = 12 }

var def = DEF()      // 원래는 스택에
let closure = {
    print(def.t)     // 캡쳐 → def가 Box에 담겨 힙으로 이동
}

핵심 정리

🔁 복습 Q&A (2026-06-30) — 클로저 내부 구조 다시 보기

func makeCounter() -> () -> Int {
    var count = 0
    return { count += 1; return count }
}
let counter = makeCounter()
counter() // 1
counter() // 2  ← count가 사라지지 않고 누적

// class — 참조만 복사 → 같은 객체 공유
class Box { var value = 0 }
var box = Box()
let c = { [box] in print(box.value) }
box.value = 10
c()   // 👉 10  (같은 Box 객체)

// struct — 값 복사 → 독립 스냅샷
struct SBox { var value = 0 }
var s = SBox()
let f = { [s] in print(s.value) }
s.value = 10
f()   // 👉 0   (캡처 시점 값 복사본)

Q4. escaping vs non-escaping 메모리 위치 (2026-07-06)

클로저와 캡처 변수의 위치

클로저 내부 지역변수는?

escaping이든 non-escaping이든 클로저 내부 지역변수는 실행 시점에 스택이다.

// 예시
var captured = 10  // 외부 변수

let closure: () -> Void = {
    // captured → 힙 (Box) - escaping이라 함수 끝나도 살아야 함

    let local = 20  // 클로저 내부 지역변수 → 실행 시 스택
    print(captured + local)
}

DispatchQueue.main.async(execute: closure)

Q5. 캡처된 변수와 ARC 동작 (2026-07-06)

예시 코드

func makeCounter() -> () -> Int {
    var count = 0                    // ① count 생성
    let closure = { () -> Int in     // ② 클로저가 count 캡처
        count += 1
        return count
    }
    return closure                   // ③ 클로저 반환
}                                    // ④ makeCounter 종료

let counter = makeCounter()          // ⑤ counter가 클로저 참조
counter()                            // ⑥ → 1
counter()                            // ⑦ → 2
// counter 스코프 종료               // ⑧ 해제

① 캡처 전 - count는 스택에

② 클로저가 count 캡처 - Box 생성

④ makeCounter 종료 - 스택 프레임 사라짐

⑤ counter가 클로저 참조

⑥⑦ counter() 호출

counter() → count += 1 → Box.value = 1
counter() → count += 1 → Box.value = 2

Box는 계속 살아있음 (refCount: 1)

⑧ counter 스코프 종료 - 해제 체인

refCount 변화 요약

Q6. Capture List가 클래스(참조 타입)에서 고정하는 것 (2026-07-06)

코드로 이해하기

class Box { var value = 10 }

var box = Box()

let closure = { [box] in      // ← capture list
    print(box.value)
}

box.value = 99                // 같은 인스턴스의 내부 변경
box = Box()                   // box 변수를 다른 인스턴스로 재할당

closure()  // 99 출력

왜 99인가?

메모리 상태 시각화

진짜 독립 복사가 필요하면?

class Box { var value = 10 }
var box = Box()

let closure = { [snap = box.value] in   // value 자체를 복사
    print(snap)                          // Int는 값 타입 → 완전히 독립
}

box.value = 99
closure()  // 10 출력 — snap은 캡처 시점의 값(10)을 가지고 있음