🔵 Weak Reference (약한 참조)

특징:
• 항상 Optional 타입이어야 함 (var로 선언)
• 참조 대상이 해제되면 자동으로 nil이 됨
• 참조 대상의 생명주기가 더 짧을 때 사용
• 안전하지만 약간의 오버헤드 존재

언제 사용할까?
참조하는 객체가 먼저 해제될 가능성이 있을 때! 예를 들어 델리게이트 패턴에서 델리게이트는 언제든 nil이 될 수 있으니까 weak을 써야 해. 🎯

class ViewController {
    weak var delegate: ViewControllerDelegate?  // weak 사용!
    
    func someAction() {
        // delegate가 nil일 수 있으니 옵셔널 체이닝 사용
        delegate?.didPerformAction()
    }
}

protocol ViewControllerDelegate: AnyObject {  // class 프로토콜이어야 함
    func didPerformAction()
}

// 실제 사용 예시
class ParentViewController: ViewControllerDelegate {
    var childVC: ViewController?
    
    func setupChild() {
        childVC = ViewController()
        childVC?.delegate = self  // weak이므로 순환 참조 없음!
    }
    
    func didPerformAction() {
        print("액션 수행됨!")
    }
    
    deinit {
        print("ParentViewController 해제")  // 정상 호출됨!
    }
}

🟣 Unowned Reference (미소유 참조)

특징:
• Optional이 아니어도 됨 (let으로 선언 가능)
• 참조 대상이 해제되어도 nil이 되지 않음
• 참조 대상이 항상 존재한다고 가정
• 해제된 객체에 접근하면 크래시 발생! 💥
• weak보다 약간 더 빠름 (nil 체크 오버헤드 없음)

언제 사용할까?
참조하는 객체가 절대 먼저 해제되지 않을 때! 예를 들어 신용카드와 고객의 관계처럼, 신용카드는 항상 고객이 있어야 존재하는 경우에 사용해. 🎯

class Customer {
    let name: String
    var card: CreditCard?
    
    init(name: String) {
        self.name = name
        print("\(name) 고객 생성")
    }
    
    deinit {
        print("\(name) 고객 해제")
    }
}

class CreditCard {
    let number: String
    unowned let customer: Customer  // unowned 사용!
    
    init(number: String, customer: Customer) {
        self.number = number
        self.customer = customer
        print("카드 \(number) 생성")
    }
    
    deinit {
        print("카드 \(number) 해제")
    }
}

// 사용 예시
var john: Customer? = Customer(name: "John")
john?.card = CreditCard(number: "1234-5678-9012-3456", customer: john!)

// Customer가 해제되면 CreditCard도 자동으로 해제됨
john = nil
// 출력:
// John 고객 해제
// 카드 1234-5678-9012-3456 해제

// ⚠️ 주의: 이렇게 하면 크래시!
var card: CreditCard?
do {
    var tempCustomer: Customer? = Customer(name: "Temp")
    card = CreditCard(number: "9999", customer: tempCustomer!)
    tempCustomer = nil  // Customer 해제
}
// print(card?.customer.name)  // 💥 크래시! customer가 이미 해제됨

🎯 실전 예시: 네트워크 요청

class ViewController {
    var data: [String] = []
    
    // ❌ 잘못된 예시
    func loadDataWrong() {
        URLSession.shared.dataTask(with: URL(string: "https://api.example.com")!) { data, response, error in
            // 클로저가 self를 강하게 캡처!
            self.data = self.parseData(data)  // 💀 순환 참조 가능성
            self.updateUI()
        }.resume()
    }
    
    // ✅ 올바른 예시 1: weak self
    func loadDataCorrect1() {
        URLSession.shared.dataTask(with: URL(string: "https://api.example.com")!) { [weak self] data, response, error in
            guard let self = self else { return }
            self.data = self.parseData(data)
            
            DispatchQueue.main.async { [weak self] in
                self?.updateUI()  // UI 업데이트는 메인 스레드에서!
            }
        }.resume()
    }
    
    // ✅ 올바른 예시 2: 캡처 리스트 활용
    func loadDataCorrect2() {
        URLSession.shared.dataTask(with: URL(string: "https://api.example.com")!) { [weak self] data, response, error in
            guard let self = self,
                  let data = data else { return }
            
            let parsedData = self.parseData(data)
            
            DispatchQueue.main.async { [weak self] in
                self?.data = parsedData
                self?.updateUI()
            }
        }.resume()
    }
    
    func parseData(_ data: Data?) -> [String] {
        // 데이터 파싱 로직
        return []
    }
    
    func updateUI() {
        print("UI 업데이트!")
    }
    
    deinit {
        print("ViewController 해제")
    }
}

🛠️ Instruments: Memory Leaks 도구

Instruments는 Xcode에 내장된 프로파일링 도구야. 메모리 누수를 찾는 가장 강력한 방법이지!

사용 방법:
1️⃣ Xcode에서 Product → Profile (⌘ + I)
2️⃣ Leaks 템플릿 선택
3️⃣ 앱 실행하면서 여러 화면 이동
4️⃣ 빨간색 막대가 나타나면 메모리 누수 발견! 🚨
5️⃣ 해당 부분 클릭하면 어디서 누수가 발생했는지 확인 가능

팁: 화면을 여러 번 왔다 갔다 해봐. 메모리가 계속 증가하면 문제가 있는 거야! 📈

📊 Memory Graph Debugger

Xcode의 Memory Graph Debugger는 실시간으로 메모리 상태를 시각화해줘!

사용 방법:
1️⃣ 앱 실행 중 디버그 바의 메모리 그래프 아이콘 클릭
2️⃣ 왼쪽에 모든 객체들이 나타남
3️⃣ 보라색 느낌표(!)가 있으면 순환 참조 의심! 💜
4️⃣ 객체를 선택하면 참조 관계를 그래프로 보여줌
5️⃣ 순환 참조를 시각적으로 확인 가능!

장점: 실시간으로 확인할 수 있어서 디버깅이 정말 편해! 🎯

🧪 deinit으로 확인하기

가장 간단한 방법은 deinit에 print문을 넣는 거야!

방법:

class MyViewController: UIViewController {
    deinit {
        print("✅ MyViewController가 정상적으로 해제됨!")
    }
}

// 화면을 나갔는데 deinit이 호출되지 않으면?
// -> 메모리 누수 발생! 🚨

팁: 모든 뷰 컨트롤러와 중요한 클래스에 deinit을 추가해봐. 개발 중에 메모리 누수를 바로바로 발견할 수 있어! 😊

🖼️ 1. 이미지 메모리 최적화

이미지는 앱에서 가장 많은 메모리를 차지해! 특히 고해상도 이미지는 정말 위험해. 😱

// ❌ 비효율적: 원본 크기 그대로 로드
class BadImageViewController: UIViewController {
    @IBOutlet weak var imageView: UIImageView!
    
    func loadImage() {
        // 4K 이미지를 작은 imageView에 표시 -> 메모리 낭비!
        imageView.image = UIImage(named: "huge_image.jpg")
    }
}

// ✅ 효율적: 필요한 크기로 리사이징
class GoodImageViewController: UIViewController {
    @IBOutlet weak var imageView: UIImageView!
    
    func loadImage() {
        guard let image = UIImage(named: "huge_image.jpg") else { return }
        
        // imageView 크기에 맞게 리사이징
        let targetSize = imageView.bounds.size
        imageView.image = resizeImage(image: image, targetSize: targetSize)
    }
    
    func resizeImage(image: UIImage, targetSize: CGSize) -> UIImage? {
        let renderer = UIGraphicsImageRenderer(size: targetSize)
        return renderer.image { _ in
            image.draw(in: CGRect(origin: .zero, size: targetSize))
        }
    }
    
    // 더 나은 방법: 다운샘플링
    func downsampleImage(at url: URL, to size: CGSize) -> UIImage? {
        let imageSourceOptions = [kCGImageSourceShouldCache: false] as CFDictionary
        guard let imageSource = CGImageSourceCreateWithURL(url as CFURL, imageSourceOptions) else {
            return nil
        }
        
        let maxDimensionInPixels = max(size.width, size.height) * UIScreen.main.scale
        let downsampleOptions = [
            kCGImageSourceCreateThumbnailFromImageAlways: true,
            kCGImageSourceShouldCacheImmediately: true,
            kCGImageSourceCreateThumbnailWithTransform: true,
            kCGImageSourceThumbnailMaxPixelSize: maxDimensionInPixels
        ] as CFDictionary
        
        guard let downsampledImage = CGImageSourceCreateThumbnailAtIndex(imageSource, 0, downsampleOptions) else {
            return nil
        }
        
        return UIImage(cgImage: downsampledImage)
    }
}

// 🚀 최고: 이미지 캐싱 + 메모리 관리
class OptimizedImageManager {
    static let shared = OptimizedImageManager()
    private let cache = NSCache<NSString, UIImage>()
    
    init() {
        // 메모리 경고 시 캐시 정리
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(clearCache),
            name: UIApplication.didReceiveMemoryWarningNotification,
            object: nil
        )
        
        // 캐시 크기 제한 (50MB)
        cache.totalCostLimit = 50 * 1024 * 1024
    }
    
    func loadImage(named name: String, size: CGSize) -> UIImage? {
        let cacheKey = "\(name)_\(size.width)x\(size.height)" as NSString
        
        // 캐시에서 확인
        if let cachedImage = cache.object(forKey: cacheKey) {
            return cachedImage
        }
        
        // 이미지 로드 및 리사이징
        guard let image = UIImage(named: name) else { return nil }
        let resized = resizeImage(image: image, targetSize: size)
        
        // 캐시에 저장 (이미지 크기를 cost로 설정)
        if let resized = resized,
           let data = resized.pngData() {
            cache.setObject(resized, forKey: cacheKey, cost: data.count)
        }
        
        return resized
    }
    
    @objc func clearCache() {
        print("⚠️ 메모리 경고! 이미지 캐시 정리")
        cache.removeAllObjects()
    }
    
    func resizeImage(image: UIImage, targetSize: CGSize) -> UIImage? {
        let renderer = UIGraphicsImageRenderer(size: targetSize)
        return renderer.image { _ in
            image.draw(in: CGRect(origin: .zero, size: targetSize))
        }
    }
    
    deinit {
        NotificationCenter.default.removeObserver(self)
    }
}

⏰ 2. 지연 초기화 (Lazy Initialization)

필요할 때만 객체를 생성하면 메모리를 절약할 수 있어! 🎯

// ❌ 비효율적: 모든 것을 미리 생성
class BadViewController: UIViewController {
    let heavyObject1 = HeavyObject()  // 사용하지 않아도 생성됨
    let heavyObject2 = HeavyObject()
    let heavyObject3 = HeavyObject()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // heavyObject1만 사용하는데 나머지도 메모리 차지!
        heavyObject1.doSomething()
    }
}

// ✅ 효율적: 필요할 때만 생성
class GoodViewController: UIViewController {
    lazy var heavyObject1 = HeavyObject()  // 처음 접근할 때 생성
    lazy var heavyObject2 = HeavyObject()
    lazy var heavyObject3 = HeavyObject()
    
    // 더 복잡한 초기화도 가능
    lazy var complexObject: ComplexObject = {
        let object = ComplexObject()
        object.configure()
        return object
    }()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // heavyObject1만 생성됨!
        heavyObject1.doSomething()
    }
}

// 🚀 실전 예시: 테이블뷰 셀
class OptimizedTableViewCell: UITableViewCell {
    // 이미지뷰를 lazy로 선언
    lazy var thumbnailImageView: UIImageView = {
        let imageView = UIImageView()
        imageView.contentMode = .scaleAspectFill
        imageView.clipsToBounds = true
        return imageView
    }()
    
    // 복잡한 뷰를 lazy로 선언
    lazy var detailContainerView: UIView = {
        let view = UIView()
        view.backgroundColor = .systemGray6
        view.layer.cornerRadius = 8
        // 복잡한 서브뷰 추가...
        return view
    }()
    
    func configure(with data: CellData) {
        // 필요한 경우에만 뷰 생성
        if data.hasImage {
            thumbnailImageView.image = data.image
            contentView.addSubview(thumbnailImageView)
        }
        
        if data.hasDetail {
            contentView.addSubview(detailContainerView)
        }
    }
}

class HeavyObject {
    init() {
        print("HeavyObject 생성 - 메모리 사용!")
    }
    
    func doSomething() {
        print("작업 수행")
    }
}

class ComplexObject {
    func configure() {
        print("복잡한 설정 수행")
    }
}

struct CellData {
    let hasImage: Bool
    let image: UIImage?
    let hasDetail: Bool
}

🔄 3. Autoreleasepool 활용

반복문에서 많은 객체를 생성할 때는 autoreleasepool을 사용해야 해!

// ❌ 비효율적: 메모리가 계속 쌓임
func processImagesWrong() {
    for i in 0..<10000 {
        let image = createLargeImage(index: i)
        processImage(image)
        // 이미지가 메모리에 계속 쌓임!
    }
    // 여기서야 메모리 해제
}

// ✅ 효율적: autoreleasepool 사용
func processImagesCorrect() {
    for i in 0..<10000 {
        autoreleasepool {
            let image = createLargeImage(index: i)
            processImage(image)
            // 블록이 끝나면 즉시 메모리 해제!
        }
    }
}

// 🚀 실전 예시: 대량 데이터 처리
class DataProcessor {
    func processLargeDataset() {
        let dataset = loadLargeDataset()  // 10만 개의 데이터
        var results: [ProcessedData] = []
        
        for (index, data) in dataset.enumerated() {
            autoreleasepool {
                let processed = processData(data)
                results.append(processed)
                
                // 진행 상황 출력 (1000개마다)
                if index % 1000 == 0 {
                    print("처리 중: \(index)/\(dataset.count)")
                }
            }
        }
        
        saveResults(results)
    }
    
    func loadLargeDataset() -> [RawData] {
        // 대량 데이터 로드
        return []
    }
    
    func processData(_ data: RawData) -> ProcessedData {
        // 데이터 처리 (메모리 많이 사용)
        return ProcessedData()
    }
    
    func saveResults(_ results: [ProcessedData]) {
        print("결과 저장: \(results.count)개")
    }
}

struct RawData {}
struct ProcessedData {}

func createLargeImage(index: Int) -> UIImage {
    // 큰 이미지 생성
    return UIImage()
}

func processImage(_ image: UIImage) {
    // 이미지 처리
}

🎯 패턴 1: 델리게이트 패턴

// ✅ 올바른 델리게이트 구현
protocol CustomViewDelegate: AnyObject {  // AnyObject 필수!
    func customViewDidTap(_ view: CustomView)
    func customView(_ view: CustomView, didChangeValue value: String)
}

class CustomView: UIView {
    weak var delegate: CustomViewDelegate?  // weak 필수!
    
    private var value: String = "" {
        didSet {
            delegate?.customView(self, didChangeValue: value)
        }
    }
    
    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        super.touchesBegan(touches, with: event)
        delegate?.customViewDidTap(self)
    }
}

class ViewController: UIViewController, CustomViewDelegate {
    var customView: CustomView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        customView = CustomView()
        customView.delegate = self  // 순환 참조 없음!
    }
    
    func customViewDidTap(_ view: CustomView) {
        print("뷰 탭됨!")
    }
    
    func customView(_ view: CustomView, didChangeValue value: String) {
        print("값 변경: \(value)")
    }
    
    deinit {
        print("ViewController 해제")  // 정상 호출됨!
    }
}

🎯 패턴 2: 클로저 기반 콜백

// ✅ 올바른 클로저 콜백 구현
class NetworkService {
    typealias CompletionHandler = (Result<Data, Error>) -> Void
    
    func fetchData(completion: @escaping CompletionHandler) {
        URLSession.shared.dataTask(with: URL(string: "https://api.example.com")!) { data, response, error in
            if let error = error {
                completion(.failure(error))
            } else if let data = data {
                completion(.success(data))
            }
        }.resume()
    }
}

class DataViewController: UIViewController {
    let networkService = NetworkService()
    var data: Data?
    
    func loadData() {
        // ✅ weak self 사용
        networkService.fetchData { [weak self] result in
            guard let self = self else { return }
            
            switch result {
            case .success(let data):
                self.data = data
                DispatchQueue.main.async { [weak self] in
                    self?.updateUI()
                }
            case .failure(let error):
                DispatchQueue.main.async { [weak self] in
                    self?.showError(error)
                }
            }
        }
    }
    
    func updateUI() {
        print("UI 업데이트")
    }
    
    func showError(_ error: Error) {
        print("에러: \(error)")
    }
    
    deinit {
        print("DataViewController 해제")
    }
}

🎯 패턴 3: 옵저버 패턴

// ✅ 올바른 NotificationCenter 사용
class NotificationViewController: UIViewController {
    var observer: NSObjectProtocol?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupNotifications()
    }
    
    func setupNotifications() {
        // weak self 사용
        observer = NotificationCenter.default.addObserver(
            forName: .dataUpdated,
            object: nil,
            queue: .main
        ) { [weak self] notification in
            self?.handleDataUpdate(notification)
        }
    }
    
    func handleDataUpdate(_ notification: Notification) {
        print("데이터 업데이트됨")
    }
    
    deinit {
        // 옵저버 제거 필수!
        if let observer = observer {
            NotificationCenter.default.removeObserver(observer)
        }
        print("NotificationViewController 해제")
    }
}

extension Notification.Name {
    static let dataUpdated = Notification.Name("dataUpdated")
}

// 🚀 더 나은 방법: Combine 사용 (iOS 13+)
import Combine

class CombineNotificationViewController: UIViewController {
    var cancellables = Set<AnyCancellable>()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupNotifications()
    }
    
    func setupNotifications() {
        NotificationCenter.default
            .publisher(for: .dataUpdated)
            .sink { [weak self] notification in
                self?.handleDataUpdate(notification)
            }
            .store(in: &cancellables)
    }
    
    func handleDataUpdate(_ notification: Notification) {
        print("데이터 업데이트됨")
    }
    
    deinit {
        // cancellables가 자동으로 정리됨!
        print("CombineNotificationViewController 해제")
    }
}

🎯 패턴 4: 타이머 관리

// ❌ 잘못된 타이머 사용
class BadTimerViewController: UIViewController {
    var timer: Timer?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // Timer가 self를 강하게 참조 -> 순환 참조!
        timer = Timer.scheduledTimer(
            timeInterval: 1.0,
            target: self,
            selector: #selector(timerFired),
            userInfo: nil,
            repeats: true
        )
    }
    
    @objc func timerFired() {
        print("타이머 실행")
    }
    
    deinit {
        print("BadTimerViewController 해제")  // 호출되지 않음!
    }
}

// ✅ 올바른 타이머 사용
class GoodTimerViewController: UIViewController {
    var timer: Timer?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        startTimer()
    }
    
    func startTimer() {
        // 클로저 기반 타이머 + weak self
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] timer in
            self?.timerFired()
        }
    }
    
    func timerFired() {
        print("타이머 실행")
    }
    
    func stopTimer() {
        timer?.invalidate()
        timer = nil
    }
    
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        stopTimer()  // 화면 나갈 때 타이머 정리
    }
    
    deinit {
        stopTimer()  // 안전을 위해 deinit에서도 정리
        print("GoodTimerViewController 해제")  // 정상 호출!
    }
}

// 🚀 더 나은 방법: 타이머 래퍼 클래스
class SafeTimer {
    private var timer: Timer?
    private weak var target: AnyObject?
    private var action: (() -> Void)?
    
    init(timeInterval: TimeInterval, repeats: Bool, target: AnyObject, action: @escaping () -> Void) {
        self.target = target
        self.action = action
        
        timer = Timer.scheduledTimer(withTimeInterval: timeInterval, repeats: repeats) { [weak self] _ in
            guard let self = self, self.target != nil else {
                self?.invalidate()
                return
            }
            self.action?()
        }
    }
    
    func invalidate() {
        timer?.invalidate()
        timer = nil
        action = nil
    }
    
    deinit {
        invalidate()
    }
}

class SafeTimerViewController: UIViewController {
    var safeTimer: SafeTimer?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        safeTimer = SafeTimer(timeInterval: 1.0, repeats: true, target: self) { [weak self] in
            self?.timerFired()
        }
    }
    
    func timerFired() {
        print("안전한 타이머 실행")
    }
    
    deinit {
        print("SafeTimerViewController 해제")  // 정상 호출!
    }
}

🎯 패턴 5: 부모-자식 관계

// ✅ 올바른 부모-자식 관계 구현
class Parent {
    var name: String
    var children: [Child] = []  // 강한 참조
    
    init(name: String) {
        self.name = name
        print("\(name) 부모 생성")
    }
    
    func addChild(_ child: Child) {
        children.append(child)
        child.parent = self
    }
    
    deinit {
        print("\(name) 부모 해제")
    }
}

class Child {
    var name: String
    weak var parent: Parent?  // 약한 참조로 순환 참조 방지!
    
    init(name: String) {
        self.name = name
        print("\(name) 자식 생성")
    }
    
    deinit {
        print("\(name) 자식 해제")
    }
}

// 사용 예시
func testParentChild() {
    var parent: Parent? = Parent(name: "부모")
    let child1 = Child(name: "자식1")
    let child2 = Child(name: "자식2")
    
    parent?.addChild(child1)
    parent?.addChild(child2)
    
    print("부모의 자식들: \(parent?.children.map { $0.name } ?? [])")
    print("자식1의 부모: \(child1.parent?.name ?? "없음")")
    
    parent = nil  // 부모 해제 -> 자식들도 자동 해제!
}

testParentChild()
/* 출력:
부모 부모 생성
자식1 자식 생성
자식2 자식 생성
부모의 자식들: ["자식1", "자식2"]
자식1의 부모: 부모
부모 부모 해제
자식1 자식 해제
자식2 자식 해제
*/

📚 Copy-on-Write란?

값 타입은 복사될 때 실제로 메모리를 복사하는 게 아니라, 수정이 일어날 때만 복사해! 이게 바로 COW야. 엄청난 성능 최적화지! ⚡

// Swift의 Array는 COW를 사용
var array1 = [1, 2, 3, 4, 5]  // 메모리 할당
var array2 = array1            // 복사하지 않고 같은 메모리 참조!

// 이 시점에서 array1과 array2는 같은 메모리를 가리킴
// 메모리 주소 확인
print("array1 주소: \(array1.withUnsafeBufferPointer { $0.baseAddress })")
print("array2 주소: \(array2.withUnsafeBufferPointer { $0.baseAddress })")
// 같은 주소!

array2.append(6)  // 이제 복사 발생!

// 이제 다른 메모리를 가리킴
print("array1 주소: \(array1.withUnsafeBufferPointer { $0.baseAddress })")
print("array2 주소: \(array2.withUnsafeBufferPointer { $0.baseAddress })")
// 다른 주소!

print("array1: \(array1)")  // [1, 2, 3, 4, 5]
print("array2: \(array2)")  // [1, 2, 3, 4, 5, 6]

🛠️ 커스텀 COW 구현

우리도 COW를 구현할 수 있어! 큰 데이터를 다룰 때 유용해. 🎯

// COW를 사용하는 커스텀 컬렉션
struct LargeDataStructure {
    // 실제 데이터는 클래스로 래핑 (참조 타입)
    private final class Storage {
        var data: [Int]
        
        init(data: [Int]) {
            self.data = data
        }
        
        func copy() -> Storage {
            return Storage(data: data)
        }
    }
    
    private var storage: Storage
    
    init(data: [Int]) {
        self.storage = Storage(data: data)
    }
    
    // 읽기 전용 접근 - 복사 없음
    var data: [Int] {
        return storage.data
    }
    
    // 쓰기 접근 - COW 적용
    mutating func append(_ value: Int) {
        // isKnownUniquelyReferenced: 참조가 하나뿐인지 확인
        if !isKnownUniquelyReferenced(&storage) {
            print("🔄 복사 발생!")
            storage = storage.copy()
        }
        storage.data.append(value)
    }
    
    mutating func removeAll() {
        if !isKnownUniquelyReferenced(&storage) {
            print("🔄 복사 발생!")
            storage = storage.copy()
        }
        storage.data.removeAll()
    }
}

// 사용 예시
var struct1 = LargeDataStructure(data: Array(1...1000))
var struct2 = struct1  // 복사하지 않음!

print("struct1 데이터 개수: \(struct1.data.count)")  // 1000
print("struct2 데이터 개수: \(struct2.data.count)")  // 1000

struct2.append(1001)  // 이제 복사 발생!
// 출력: 🔄 복사 발생!

print("struct1 데이터 개수: \(struct1.data.count)")  // 1000
print("struct2 데이터 개수: \(struct2.data.count)")  // 1001

// 🚀 실전 예시: 이미지 데이터 구조체
struct ImageData {
    private final class Storage {
        var pixels: [UInt8]
        let width: Int
        let height: Int
        
        init(width: Int, height: Int) {
            self.width = width
            self.height = height
            self.pixels = Array(repeating: 0, count: width * height * 4)  // RGBA
        }
        
        func copy() -> Storage {
            let newStorage = Storage(width: width, height: height)
            newStorage.pixels = pixels
            return newStorage
        }
    }
    
    private var storage: Storage
    
    init(width: Int, height: Int) {
        self.storage = Storage(width: width, height: height)
    }
    
    var width: Int { storage.width }
    var height: Int { storage.height }
    
    // 픽셀 읽기 - 복사 없음
    func getPixel(x: Int, y: Int) -> (r: UInt8, g: UInt8, b: UInt8, a: UInt8) {
        let index = (y * width + x) * 4
        return (
            storage.pixels[index],
            storage.pixels[index + 1],
            storage.pixels[index + 2],
            storage.pixels[index + 3]
        )
    }
    
    // 픽셀 쓰기 - COW 적용
    mutating func setPixel(x: Int, y: Int, r: UInt8, g: UInt8, b: UInt8, a: UInt8) {
        if !isKnownUniquelyReferenced(&storage) {
            storage = storage.copy()
        }
        
        let index = (y * width + x) * 4
        storage.pixels[index] = r
        storage.pixels[index + 1] = g
        storage.pixels[index + 2] = b
        storage.pixels[index + 3] = a
    }
}

// 사용 예시
var image1 = ImageData(width: 1920, height: 1080)
var image2 = image1  // 복사하지 않음! 메모리 절약!

// 읽기만 하면 복사 안 됨
let pixel = image1.getPixel(x: 100, y: 100)

// 쓰기를 하면 복사 발생
image2.setPixel(x: 100, y: 100, r: 255, g: 0, b: 0, a: 255)
// 이제 image1과 image2는 다른 메모리를 사용

📝 핵심 요약

1. ARC의 기본 원리 🔄
• 참조 카운트를 자동으로 관리
• 카운트가 0이 되면 자동 해제
• 힙 메모리의 참조 타입에만 적용

2. 순환 참조 방지 ⚠️
• weak: 참조 대상이 먼저 해제될 수 있을 때
• unowned: 참조 대상이 항상 존재할 때
• 확신이 없으면 weak 사용!

3. 클로저 캡처 리스트 🔐
• [weak self] 패턴 습관화
• guard let self = self 활용
• 비동기 작업에서 특히 주의

4. 메모리 최적화 ⚡
• 이미지 리사이징
• lazy 프로퍼티 활용
• autoreleasepool 사용
• 적절한 캐싱 전략

5. 디버깅 도구 🔍
• Instruments의 Leaks
• Memory Graph Debugger
• deinit 로깅
• 정기적인 프로파일링

6. 실전 패턴 🎯
• 델리게이트는 항상 weak
• 타이머는 반드시 invalidate
• 옵저버는 제거 필수
• 부모-자식 관계 주의

🎓 다음 단계로 나아가기

메모리 관리를 마스터하려면 계속 연습하고 경험을 쌓아야 해! 다음 단계들을 추천해:

1. 실전 프로젝트 만들기
• 이미지 편집 앱
• 실시간 채팅 앱
• 비디오 플레이어
• 게임 앱

2. 오픈소스 분석
• 유명한 iOS 라이브러리 코드 읽기
• 메모리 관리 패턴 학습
• 베스트 프랙티스 습득

3. 커뮤니티 참여
• Stack Overflow에서 질문/답변
• GitHub 이슈 참여
• 재능넷 같은 플랫폼에서 멘토링 받기

4. 지속적인 학습
• WWDC 세션 시청
• Swift Evolution 팔로우
• 기술 블로그 구독

5. 성능 측정 습관
• 매 릴리즈 전 프로파일링
• 메모리 사용량 모니터링
• 성능 지표 추적

🌟 축하합니다! 🌟

Swift 메모리 관리와 ARC의 모든 것을 마스터했어요!
이제 메모리 누수 없는 완벽한 앱을 만들 준비가 되었습니다.

계속해서 연습하고, 실험하고, 배우세요!
당신은 이미 훌륭한 iOS 개발자입니다! 💪✨

Happy Coding! 🎉