Youre welcome!

Youre welcome!

Thank you!

Thanks! Did you like my balloon example hahaha

Thanks!

Glad it helped

Ha ha you’re welcome, glad I could help. Don’t forget to subscribe!

Thanks!

Your welcomd! Dont forget to subscribe and like

Thanks

Youre welcome

Youre welcome & sure! Added to my list

Glad to hear it

Thanks!

haha thanks!

Youre welcome! Glad i could help

Will do soon

Coming soon

Was waiting for someone to point this out. Glad to know I'm not going crazy.

Weak is needed to avoid retain cycle.

iOS Academy but optional doesn't already have weak reference?

Yes, I have also some confusion, as video tutorial states that the code doesn’t give any error but if give weak self then it will not leak the memory. Then how do we know when n where memory will leak?

Tell me if I’m wrong.. but I think it’s because the AlertController is not owned by the “ViewController”. Once dismissed, the AlertController has no reference pointing it and it is released.

The answer is simple, what this youtuber said is not correct about the alert controller. The alert controller is not owned by "self", so there is no retain cycle. He is misleading others.

Hi westo127! My response may not be the most precise or accurate as I am also still learning, but this is my understanding of iOS memory management. To address your question, the object's data type (i.e. Struct) isn't the concern. A retain cycle occurs when two separate objects are strongly pointing to (referencing) each other; if one of the objects is deallocated (removed) from memory while another object is still strongly referencing it, the object that is referencing the deallocated object will still exist in memory somewhere, pointing to (or otherwise linked to) some object that no longer exists in memory - taking up space while serving no purpose. The goal of proper memory management is to ensure that objects that are added to memory are deallocated if they are no longer being used. In the example provided, there are two objects: ViewController and Alert. The parent ViewController object is strongly pointing to a child Alert object because the Alert object is defined within the ViewController object; this Alert object is a separate object from the ViewController object though it is defined in the ViewController class. If memory is properly managed, the Alert object should be deallocated from memory if the ViewController gets deallocated from memory. Before the edit was made to the Alert object's handler, the Alert object was strongly referencing the parent ViewController class by calling the parent ViewController's method 'doSomething()'. Since the ViewController object strongly references the Alert object and the Alert object is strongly referencing the ViewController by calling the ViewControllers doSomething() method, this causes a retain cycle. To prevent a retain cycle, you want the child Alert object to weakly reference the ViewController's doSomething method; that way when the user dismisses the Alert object from the View - an action that should deallocate the Alert object from memory - the strong reference to the ViewController won't prevent that from happening. Hope this was helpful and not just a reiteration of what was previously discussed in the video. :)

Strong is default because you don’t want your object to just disappear when you need it, do you? So figure out how you want to handle it, and then use weak.

Agreed

Yes, almost 99 percent of time

Swlf is needed in closures

When you want to ref to your current variable inside VC, for example in init u can assign what u get as a param into your local variable. for exmaple - self.count = count(the param that u get from the user). btw there's self in every programming langue :)

We’ve all been there!

Yep haha

Thanks for the feedback