Balance retain with release?

Question

I am just curious, do I need to add a further [name release] elsewhere to match up with the retain here in the getter?

- (NSString *)name {
    return [[name retain] autorelease];
}

gary

Answer 1

No, this is fine. autorelease will cause the value to be released when the current autorelease pool is drained.

Every retain must be matched with exactly 1 of either release or autorelease.

However, I believe both the retain and autorelease are unneeded here. Generally you want to use that autorelease idiom because you've alloc'ed something in the method.

Answer 2

No, but you shouldn't need to do this at all since you are not allocating anything. You could simply return name and that should be fine. Was there a reason you needed to add this retain/autorelease?

A little more explanation, what is happening here is that your retain count goes up by one when you do a retain, and then down by 1 when the scope exists because of the autorelease.

Answer 3

No. The autorelease will balance it out. I don't think, however, that the retain and autorelease would be necessary. You can simply use return name.

Answer 4

I don't know how your variable definition is in your class but the rule is that in your getter you should return the object unchanged for the reference count. It's the responsability of the caller to call retain if it want to keep a reference on it.

- (NSString*) name {
  return name;
}

// caller
NSString* name = object.name;
[name retain]; // if necessary. If the string is used only in the context of a method you do not have to retain it.

If you are using the returned value as a field in another class you should define your field like this:

@property(retain, nonatomic) NSString* name;

With this a retain will be called when you assign to the variable.

Answer 5

I think I might have figured it out:

if [myString] is created outside the method then your safe to use ...

return myString;

if on the other hand [myString] is created inside the method and therefore needs to be released and returned, then you use.

myString = [[NSString alloc] initWithFormat: @"Send me home"]; 
return [myString autorelease];

This way the method sets [myString] to autorelease, Basically the object is created, set to autorelease and returned. The object will ultimately be released when the pool is destroyed.

Answer 6

As others have said, you do not need to retain or autorelease the property. Since callers of the 'getter' method did not create the object, they do not own it, and you are safe to assume that they won't tinker around with its retain count.

But, callers could potentially change the value of the variable returned by the getter, which would affect the object. Therefore, it would probably be a better idea to return a copy of your variable, especially since it is an NSString. (Getters for NSString objects often return a copy.)

- (NSString *)name {
    return [[name copy] autorelease];
}

In this scenario, you are creating a copy of the variable, so you 'own' it. By autoreleasing it before it is returned, you ensure that it will survive long enough to be used in the caller's scope, and that any changes they make to the 'name' variable will not affect the underlying object.

Answer 7

I am just curious, do I need to add a further [name release] elsewhere to match up with the retain here in the getter?

- (NSString *)name {
    return [[name retain] autorelease];
}

No, because you are already releasing it. autorelease just means “send yourself release later”.

I think you should review the memory-management rules.