weak-references

I have a doubt regarding weak property in ARC (auto reference counting) My understanding (correct me if I am wrong): weak property behaves similar to the assign property except that when the instance that the property was pointing to gets destroyed, the ivar is made to point to nil. Question: I just feel that the getter of the weak property retains and autoreleases. Isn't it suppose to behave like getter of the assign property where the getter doesn't retain and autorelease ?(pls refer to the program) Program: I have given below the program with the actual output and my expected output. Note -

The .NET 4.0 ConditionalWeakTable<T> is effectively a dictionary where the dictionary's keys are weak referenced and can be collected, which is exactly what I need. The problem is that I need to be able to get all live keys from this dictionary, but MSDN states : It does not include all the methods (such as GetEnumerator or Contains) that a dictionary typically has. Is there a possibility to retrieve the live keys or key-value pairs from a ConditionalWeakTable<T> ? I ended up creating my own wrapper: using System; using System.Collections.Generic; using System.Linq; using System.Runtime

Here's an academic question about object finalization and collection in C#/.NET. Background reading is section 3.9 of the C# language spec, Automatic Memory Management. When there are no explicit references to an object, it may become garbage collected. It becomes "eligible for destruction". At some point in the future (e.g. if you force garbage collection), the object's destructor will be run. In the destructor, if you save a reference to the object, the object will be finalized, but will not be eligible for collection. This can lead to an object being in a state where it has been finalized,

Mike Ash has written this introduction to ARC where he introduces something like: __weak Foo *_weakFoo = [object foo]; Why would I want to do that for a local, temporary variable? __weak is a zeroing reference which will set the _weakFoo pointer automatically to nil as soon as the referenced object gets deallocated. Also, __weak is only available in iOS >= 5. When would I run into trouble when I simply do this?: Foo *_weakFoo = [object foo]; This is always expected to return an object or nil. My guess is this: Foo *_weakFoo = [object foo]; [self doSomethingStupid]; // does something bad so foo

Is there any way to check an unowned(safe) Swift reference for "availability"? So, I am looking for a hypothetical function like isReferenceAccessible in this example: func someMethod() { someAsyncOperation(parameters) { [unowned(safe) self] in guard isReferenceAccessible(self) else { return } self.someAnotherMethod() } } Disclaimer: This question not about weak references! I am aware of how strong , unowned and weak references work. And I don't want to use weak references (because it can be slow, and mutable). I know that unowned(safe) references still be allocated even if it is already

I know that weak references are a good candidate for memoizing potentially large sets of data, and Wikipedia's article on weak references only lists "keeping track of the current variables being referenced in the application" and the statement "Another use of weak references is in writing a cache". What are some other situations (more specific than just "caching results") where the use of weak references is A Good Idea TM ? In Flex, use weak references to avoid memory leaks . If an event handler is a member of a short-lived instance object, passing the handler as a strong reference to an