unowned reference - ios

Question

using unowned to reference to an object:
when the object is deallocated, the other object that has a reference was marked unowned, that object is also deallocated at the same time. But what about that object also contains other reference to other object without marking unowned?
class Base {
let str: String
init(str: String){
self.str = str
}
deinit {
print("leaving Base class with string, \(str).")
}
}
class Country {
let name: String
var capitalCity: City!
init(name: String, capitalName: String) {
self.name = name
self.capitalCity = City(name: capitalName, country: self)
}
deinit {
print("Leaving Country class")
}
}
class City {
let name: String
let baseClass: Base = Base(str: "ABC") // reference to other object.
unowned let country: Country
init(name: String, country: Country) {
self.name = name
self.country = country
}
deinit {
print("Leaving City class")
}
}
var hk: Country? = Country(name: "Hong Kong", capitalName: "Central")
let central = City(name: "Central", country: hk!)
let base = central.baseClass
print("here")
hk = nil
print("here")
print(base.str)
print("here")
//print:
//here
//Leaving Country class
//Leaving City class
//leaving Base class with string, ABC.
//here
//ABC
//here
this object with two properties that points to two different objects. one property was marked unowned. the other property was not marked unowned. So, I thought it would have made a strong reference due to not mark unowned for one of the properties. but this object was still deallocated from my test code. the strange thing is after deallocation, i can still access the property. why? and how unowned works? how should i mark it?

Answer 1

class Country {
...
init(name: String, capitalName: String) {
...
self.capitalCity = City(name: capitalName, country: self) // <-- o_O
The "leaving Base class" you see is not related to central.
In your Contry's constructor you have created a new instance of City, and thus a new Base will also be created. So what is destroyed is just hk!.capitalCity.baseClass which is unrelated to central.baseClass.
These have nothing to do with unowned.

Answer 2

Let's look at these lines of code:
var hk: Country? = Country(name: "Hong Kong", capitalName: "Central")
let central = City(name: "Central", country: hk!)
let base = central.baseClass
print("here")
hk = nil
print("here")
print(base.str)
print("here")
After the first line, three objects are created: Country, City and Base. Here are the references:
1. Country -> City: strong
2. City -> Country: weak
3. City -> Base: strong
After the second line, another two objects are created: another City and another Base. References:
4. second City -> Country: weak
5. second City -> second Base: strong
All right, now we deallocate hk! Which references will point to nothing? It's 2 and 4. This means that we can ignore them. Which reference will be destroyed? It's reference 1!
Now reference 1 is destroyed, there are no strong reference pointing to the first City you created! Hence, the first city will be deallocated and print the message.
After the first city is deallocated, there are no strong reference pointing to the first Base you created, and hence it is deallocated as well, printing the message.
What you are accessing in the second to last line of code, is the second City!
Here's a picture:
Dotted lines represent weak references. Non-dotted lines represent strong references.
"The second city also has no strong reference attached! Why isn't it deallocated?" you asked. Well, that is because it is stored in a local variable called central!
PS Hong Kong is not a country. And Central is not its capital. Central is just a busy district in Hong Kong.