Swift: Swiftメモリ管理とARCチュートリアル：自動参照カウントと循環参照の修正

// Before fix: retain cycle
class Message {
    let text: String
    var sender: User?  // Strong reference
}
class User {
    let name: String
    var lastMessage: Message?  // Strong reference
}
// After fix: use weak reference on one side to break the cycle
class User {
    let name: String
    weak var lastMessage: Message?  // Weak reference
}

// ============================================
// Observing ARC reference count and deinit timing
// ============================================
class Person {
    let name: String
    init(name: String) { self.name = name; print("\(name) initialized") }
    deinit { print("\(name) deallocated") }
}
var alice: Person? = Person(name: "Alice")  // count = 1
var ref2 = alice                              // count = 2
print("Before ref2 = nil")
ref2 = nil                                    // count = 1
print("After ref2 = nil")
print("Before alice = nil")
alice = nil                                   // count = 0 -> deinit
print("After alice = nil")

// ============================================
// Retain cycle demo: Message and User hold each other
// ============================================
class Message {
    let text: String
    var sender: User?
    init(text: String) { self.text = text; print("Message initialized: \(text)") }
    deinit { print("Message deallocated: \(text)") }
}
class User {
    let name: String
    var lastMessage: Message?
    init(name: String) { self.name = name; print("User initialized: \(name)") }
    deinit { print("User deallocated: \(name)") }
}
print("--- Create ---")
var user: User? = User(name: "Bob")
var msg: Message? = Message(text: "Hello")
user?.lastMessage = msg
msg?.sender = user
print("--- Set nil ---")
msg = nil
user = nil
print("--- Observe output ---")
print("Notice: deinit was NOT triggered -- objects leaked!")

// ============================================
// Retain cycle caused by a closure
// ============================================
class NetworkManager {
    var onComplete: (() -> Void)?
    let url: String
    init(url: String) { self.url = url; print("Manager initialized") }
    deinit { print("Manager deallocated") }
    func start() {
        onComplete = {
            print("Request completed: \(self.url)")
        }
    }
}
print("--- Create ---")
var manager: NetworkManager? = NetworkManager(url: "https://api.example.com")
manager?.start()
print("--- Set nil ---")
manager = nil
print("--- Observe ---")
print("deinit NOT triggered -- closure captures self, causing a leak")

// ============================================
// Using weak to break the retain cycle between classes
// ============================================
class Message {
    let text: String
    weak var sender: User?  // weak breaks the cycle
    init(text: String) { self.text = text; print("Message initialized: \(text)") }
    deinit { print("Message deallocated: \(text)") }
}
class User {
    let name: String
    var lastMessage: Message?
    init(name: String) { self.name = name; print("User initialized: \(name)") }
    deinit { print("User deallocated: \(name)") }
}
print("--- After fix ---")
var user: User? = User(name: "Bob")
var msg: Message? = Message(text: "Hello")
user?.lastMessage = msg
msg?.sender = user
print("--- Set nil ---")
msg = nil    // Message freed
user = nil   // User freed
print("--- Deallocated normally ---")

// ============================================
// Capture list fixes the closure retain cycle
// ============================================
class NetworkManager {
    var onComplete: (() -> Void)?
    let url: String
    init(url: String) { self.url = url; print("Manager initialized") }
    deinit { print("Manager deallocated") }
    func start() {
        onComplete = { [weak self] in
            guard let self = self else { return }
            print("Request completed: \(self.url)")
        }
    }
}
print("--- After fix ---")
var manager: NetworkManager? = NetworkManager(url: "https://api.example.com")
manager?.start()
manager = nil
print("--- Manager deallocated ---")

// ============================================
// Full example: Memory-safe chat message management
// Uses weak/unowned + capture lists
// ============================================
import Foundation
// 1. User model
class UserProfile {
    let id: Int
    let name: String
    weak var latestMessage: Message?  // weak breaks the cycle
    var messages: [Message] = []
    init(id: Int, name: String) {
        self.id = id
        self.name = name
        print("UserProfile \(name) initialized")
    }
    deinit { print("UserProfile \(name) deallocated") }
    // 2. Use capture list in closure
    func createAutoReply() -> (() -> String) {
        return { [weak self] in
            guard let self = self else { return "User is offline" }
            return "\(self.name): Auto-reply - I'll get back to you later"
        }
    }
}
// 3. Message model
class Message {
    let id: Int
    let text: String
    var sender: UserProfile?  // Sender
    init(id: Int, text: String, sender: UserProfile?) {
        self.id = id
        self.text = text
        self.sender = sender
        print("Message #\(id) initialized")
    }
    deinit { print("Message #\(id) deallocated") }
}
// 4. Usage example
print("=== Send message ===")
var alice: UserProfile? = UserProfile(id: 1, name: "Alice")
var msg1: Message? = Message(id: 101, text: "Hello!", sender: alice)
alice?.latestMessage = msg1
msg1?.sender = alice
let reply = alice?.createAutoReply()
print(reply?() ?? "")
print("\n=== Exit chat ===")
msg1 = nil
alice = nil
print("=== All objects deallocated ===")