retain

For iOS developers, delegates are used almost everywhere. And seems like that we need to use "assign" instead of retain for a delegate like this @property(assign) id delegate; The reason is to avoid the circular loop issue Why are Objective-C delegates usually given the property assign instead of retain? I saw a lot of code and they still used "retain". So the question here is will we still get the circular loop issue if we use retain for a delegate? Thanks vfn The documentation says: Retaining an object creates a strong reference, and an object cannot be deallocated until all of its strong

Isn't it unnecessary to retain a static variable since it stays around for the duration of the program, no matter if you release it? See this code: https://github.com/magicalpanda/MagicalRecord/blob/master/Source/Categories/NSManagedObjectContext+MagicalRecord.m#L24-29 I'm assuming you mean a static object pointer, such as static NSString *foobar; . Such variables indeed have a lifetime as long as the application, but the variables we're talking about are pointers only . In Objective-C, objects are always dynamically allocated, and so we always address them with a pointer to their type, but

I'm new to memory managed code but I get the idea pretty well. On taking my app through the leaks tool in XCode, I noticed I only had to clean up my custom objects, but not dynamically created arrays for example, so I figured those data types are autoreleased - makes sense since I only had to release the arrays I used as properties that had a (retain) on them. Then I noticed something peculiar : I was getting a leak on a certain array initialized like this : NSMutableArray *removals = [NSMutableArray new]; but not a similar one NSMutableArray *removals = [NSMutableArray arrayWithCapacity:9];

In a Cocoa Touch project, I need a specific class to have not only a single delegate object, but many of them. It looks like I should create an NSArray for these delegates; the problem is that NSArray would have all these delegates retained, which it shouldn't (by convention objects should not retain their delegates). Should I write my own array class to prevent retaining or are there simpler methods? Thank you! I found this bit of code awhile ago (can't remember who to attribute it to). It's quite ingenius, using a Category to allow the creation of a mutable array that does no retain/release

A 101 question Let's say i'm making database of cars and each car object is defined as: #import <UIKit/UIKit.h> @interface Car:NSObject{ NSString *name; } @property(nonatomic, retain) NSString *name; Why is it @property(nonatomic, retain) NSString *name; and not @property(nonatomic, assign) NSString *name; ? I understand that assign will not increment the reference counter as retain will do. But why use retain , since name is a member of the todo object the scope of it is to itself. No other external function will modify it either. Chuck There's no such thing as the "scope of an object" in