In Swift, if BOTH the parent and child classes have weak references, then what will happen?

Question

When implementing code in Swift, we always are careful to avoid retaining the cycle, and we avoid using weak or unowned. What will happen if we declare weak for all references, all variables/properties? In short, if we never create strong references, what impact should we expect? Why by default swift creates strong references and not weak ones? I tried to ask the same to chatGPT and the response confused me. (I know it is an AI, can give wrong results to such specific questions

I couldn't find an explanation for this anywhere. Would really appreciate if someone can explain this with an example.

Answer 1

According to Swift.org,

To make sure that instances don’t disappear while they’re still needed, ARC tracks how many properties, constants, and variables are currently referring to each class instance. ARC will not deallocate an instance as long as at least one active reference to that instance still exists.

To make this possible, whenever you assign a class instance to a property, constant, or variable, that property, constant, or variable makes a strong reference to the instance. The reference is called a “strong” reference because it keeps a firm hold on that instance, and doesn’t allow it to be deallocated for as long as that strong reference remains.

So if nothing has a strong reference to anything else, all the reference-type objects get deallocated. As you can see from the warning produced by this code:

// Instance will be immediately deallocated because variable 'x' is 'weak'
weak var x = UIView()

On the other hand, value types like structs and enums are not part of the ARC system, so you can still use them. In fact, you can often write simple SwiftUI code purely with value types (though those value types may internally contain strong references to other things).

However, if you use a stricter definition of "declare weak for all references, all variables/properties", such that you are not allowed to use any existing type that has a strong reference, you would not even be able to use the Swift collection types like arrays or sets, since those contain strong references to their underlying storage. At that point, Swift kind of just becomes C, and you are not getting any of the benefits of ARC at all, and probably needs to do your own memory management.

All this is to say that if you are avoiding strong references just because you are afraid of a reference cycle, that's like saying you will never go out of your house because you are afraid of getting hit by a car. Yes, strong reference cycles can happen, but the way to handle them is not to avoid strong reference cycles at all costs. Your program wouldn't be able to do much because of that.