Question

Assuming, the following declaration for class A

@property(nonatomic, assign) DoublyLinkedList *doublyLinkedList;

, that as part of init, initialized the object

- (id)init {
    self = [super init];
    if (self) {
        doublyLinkedList = [[DoublyLinkedList alloc] init];
    }

    return self;
}

and that a method

- (DoublyLinkedList*) doSomethingAndReturn {

that ultimately

return doublyLinkedList;

Does class A owns the doublyLinkedList after the return?

Answer 1

EDIT: init added with alloc

You are not calling retain on it, but in init you are calling alloc on it, so it does have a retain count of 1 — you own it and you should release it in dealloc.

You could simply alloc it and release it in dealloc. The caller of the property can choose whether to retain. Another option would be to create the object in init, autorelease it and then assign it to the property with (retain) instead of (assign). That way, if other places in the code alloc and assign to that property, the object you alloc‘d will get released. Then in dealloc, what it’s currently assigned to will get released.

Yet another option if you don’t want others to set it would be to have a (readonly) property and a _doubleLinkedList iVar and then @synthesize doublyLinkedList = _doubleLinkedList. Then you can allocate it once in init and know that no one else will assign it, and then release it in dealloc.

A good analogy is that when you retain, you’re putting a leash on it. Multiple items can put a leash on that object. It is freed only when everyone has taken the leash off.

A good guide to read:

Apple’s Memory Management Programming Guide

Specifically from that doc, these rules help:

You own any object you create You create an object using a method
whose name begins with “alloc”, “new”, “copy”, or “mutableCopy” (for
example, alloc, newObject, or mutableCopy).

You can take ownership of an object using retain A received object
is normally guaranteed to remain valid within the method it was
received in, and that method may also safely return the object to its
invoker. You use retain in two situations: (1) In the implementation
of an accessor method or an init method, to take ownership of an
object you want to store as a property value; and (2) To prevent an
object from being invalidated as a side-effect of some other operation
(as explained in “Avoid Causing Deallocation of Objects You’re
Using”).

When you no longer need it, you must relinquish ownership of an
object you own You relinquish ownership of an object by sending it a
release message or an autorelease message. In Cocoa terminology,
relinquishing ownership of an object is therefore typically referred
to as “releasing” an object.

You must not relinquish ownership of an object you do not own This
is just corollary of the previous policy rules, stated explicitly.