retain cycle

클래스 인스턴스의 래퍼런스 카운트가 남아있으면 메모리에서 해제되지 않는다. (리테인 사이클이 아니더라도.)

class A {
    var b: B?
    init(b: B?) {
        self.b = b
    }
    deinit {
        print("A deinit")
    }
}

class B {
    var c: C?
    init(c: C?) {
        self.c = c
    }
    deinit {
        print("B deinit")
    }
}

class C {
    var d: D?
    init(d: D?) {
        self.d = d
    }
    deinit {
        print("C deinit")
    }
}

class D {
    var a: A?
    init(a: A?) {
        self.a = a
    }
    deinit {
        print("D deinit")
    }
}

var a: A? = A(b: nil)
var b: B? = B(c: nil)
var c: C? = C(d: nil)
var d: D? = D(a: nil)

a?.b = b
b?.c = c
c?.d = d
d?.a = a

//b?.c = nil /
a = nil
b = nil
c = nil
b?.c = nil //이 코드는 무효화된다. b가 nil므로.
d = nil

var a1: A? = A(b: nil)
var b1: B? = B(c: nil)
a1?.b = nil
print(b1)

class K {
    var p: P?
    init(p: P?) {
        self.p = p
    }
    deinit {
        print("K deinit")
    }
}

class P {
    var k: K?
    init(k: K?) {
        self.k = k
    }
    deinit {
        print("P deinit")
    }
}

var k: K? = K(p: nil)
var p: P? = P(k: nil)
k?.p = p

아래와 같이 weak으로 선언할경우, k=nil이면 k가 deinit된다. Weak이 아닐경우, 해제되지 않는다.