CODEWITHSUNDEEP
objective-cswiftautomatic-ref-counting
TruMan1
TruMan1

Reputation: 36098

Disadvantages of using weak variables even when not needed?

Seems Automatic Reference Counting (ARC) puts so much burden on the developer to keep track of references. Why couldn't you just make every variable weak and not have to worry about the strong retain cycles happening at all?

Upvotes: 1

Views: 525

Answers (3)

Luke Smith
Luke Smith

Reputation: 1320

Im afraid you just dont understand ARC. ARC does the counting of references for you, depending on whether something is defined as strong or weak (in effect, strong increases the reference count, while weak does not). If a reference count becomes 0, it is removed from memory. So if everything was weak, properties would be removed from memory immediately, and you could not use them. You need a strong somewhere, in effect.

As a simple way to plan how to structure your strong / weak definitions, think of one particular class as the owner of a property, and give that one the strong. This means the property will stick around for that owner to use it. If another class also has a reference to that property, but does not require that the property always sticks around for it - make that weak. As long as the main owner class, say the View Controller, still exists - then so will the property. If both were set weak, then even though the property still appears, it will be empty, because at runtime, it was decided that no-one really needed it, and it was removed.

Upvotes: 4

Dalija Prasnikar
Dalija Prasnikar

Reputation: 28516

Under ARC object instance is alive as long as there is at least one strong reference to that object instance.

If you mark all variables as weak, there would be no strong references to object instance and nothing could keep it alive. It would be destroyed immediately upon creation.

If you are taking more than single reference to object instance you have to think about whether it should be marked as weak or strong (depending on particular code), there is no way around it.

Upvotes: 0

Hermann Klecker
Hermann Klecker

Reputation: 14068

This is because you will need one strong reference as long as you need a reference to the object, as long as you need the referred object to survive in memory.

(You could go back to Objective-C where you can do all the works without ARC and do the memory management manually on your own. Apparently this could make you appreciate ARC.)

On the other hand you could ask the same question for strong references. The difference is that when you keep strong references only (no weak ones) then you don't have to think about weak or strong and it would work. (weak alone will most likely not work) But then you would have to be 100% sure to null every strong reference to each object that you don't need anymore.

Side note: When you add your object to a collection such as an array or a set (or as subview to a view) then these collection objects will keep strong references for you. In that case you don't have to care but to remove the object from that collection when the object can be discarded. This "trick" is only appropriate when you maintain these collections anyway - e.g. when it is about views that are part of the view hierarchy as long as they are required.

Upvotes: 1

Related Questions