ObjectiveC - Releasing objects added as parameters

Question

Ok, here goes.

Being a Java developer I'm still struggling with the memory management in ObjectiveC. I have all the basics covered, but once in a while I encounter a challenge.

What I want to do is something which in Java would look like this:

MyObject myObject = new MyObject(new MyParameterObject());

The constructor of MyObject class takes a parameter of type MyParameterObject which I initiate on-the-fly.

In ObjectiveC I tried to do this using following code:

MyObject *myObject = [[MyObject alloc] init:[[MyParameterObject alloc] init]];

However, running the Build and Analyze tool this gives me a "Potential leak of an object" warning for the MyParameter object which indeed occurs when I test it using Instruments. I do understand why this happens since I am taking ownership of the object with the alloc method and not relinquishing it, I just don't know the correct way of doing it. I tried using

MyObject *myObject = [[MyObject alloc] init:[[[MyParameterObject alloc] init] autorelease]];

but then the Analyze tool told me that "Object sent -autorelease too many times".

I could solve the issue by modifying the init method of MyParameterObject to say return [self autorelease]; in stead of just return self;. Analyze still warnes about a potential leak, but it doesn't actually occur. However I believe that this approach violates the convention for managing memory in ObjectiveC and I really want to do it the right way.

Thanx in advance.

Answer 1

Ok, here's a suggestion.

MyParameter *param = [[MyParam alloc] init];
MyObject *obj = [[MyObject alloc] initWithParam:param]; // do you know if param is retain'd or not?
[param release];

Why do it this way? This is the pattern used throughout ObjC/Cocoa. You add objects to NSArrays this way:

MyThing *thing = [[MyThing alloc] init];
[myMutableArray addObject: thing]; // this calls [thing retain]
[thing release];

You may also want to try to do this:

MyObject *obj = [[MyObject alloc] initWithParam: [MyParameter parameter]];

where:

+ (id) parameter
{
    return [[[self alloc] init] autorelease];
}    

that way you don't have to worry about it. This is the same as

[NSData data];
[NSArray array];

I hope that helps. Generally, it isn't a good idea to use init during another method call (like a setter or another init). Hiding it behind a Class Method (+ (id) parameter) means the user knows it'll be autorelease'd.

If you're ever unclear about how many retain's or release's something has, you can always do something like this:

---

[EDIT]

Caveat: Apparently you should never use -retainCount. I find it useful for teaching learners the basics of retain'd Memory Management, but the point is well taken.

Never Use it in actual code or for performance testing. This is only used to learn what retain does (and I believe it functions properly in this case). It will never give you an intelligent answer for an object which is autorelease'd or further retain'd by a NSArray or Other Foundation/AppKit/UIKit Classes

MyParameter *param = [[MyParam alloc] init];
NSLog(@"param retain count: %d",[param retainCount]); // should be 1
MyObject *obj = [[MyObject alloc] initWithParam:param];
NSLog(@"param retain count: %d",[param retainCount]); // should be 2, if MyObject retains it.
[param release];
NSLog(@"param retain count: %d",[param retainCount]);  // should be 1

---

Also, when you dealloc MyObject, you'll need to release param if you retain'd it during initialization.

The following guide put out by Apple should help you to understand Objective-C Memory Management a little better.

Answer 2

MyThing *thing = [[MyThing alloc] init];
[otherThing methodWithAThing:thing];
[thing release];

or:

[otherThing methodWithAThing:[[[MyThing alloc] init] autorelease]];

or (if there is a "convenience constructor" on the class you're using):

[otherThing methodWithAThing:[MyThing thing]];

Answer 3

MyObject *myObject = [[MyObject alloc] init:[[[MyParameterObject alloc] init] autorelease]];

should be ok, if there is no release in the init (there should definitely not be a release in the init). I often make a class method which makes a autoreleased object. So the code would be:

// using it:
MyObject *myObject = [[MyObject alloc] init:[MyParameterObject defaultParameters];

// in the class implementation of MyParameterObject
+ (MyParameterObject*) defaultParameters{
    MyParameterObject* out = [[MyParameterObject alloc] init];
    // set some values
    return [out autorelease];
}

Answer 4

[[MyObject alloc] init:[[[MyParameterObject alloc] init] autorelease]]

Without knowing what's going on in the init method, this seems fine.

NB, though, that it's more Objective-Cish to spell this "initWithParameterObject:". Though they gag people new to the language, Obj-C's descriptive method names are actually really helpful for code readability.