Question

thanks for viewing this post, it’d be great if you guys can help me out. I’ve been doing some objective-c and learned about the objective-c way of memory management, like making sure to call release whenever I own the object, when to call autorelease, etc. I also do not want to use ARC or the newly introduced GC because I like to manage my own memory, I plan to advance later on into iOS development, and I know it’s a good practice to manage my own memory. But there’s still one small detail that I seem to have hit a brick wall in. It has to do with sending objects the -retain message. I learned that sending the -retain message increments the reference count by 1. But would this be an appropriate time to send -retain? :

      - (void) setName : (NSString* ) theName 
      {
          // name is an instance variable of type NSString
          [theName retain]; // Must release this
          name = [theName copy]; // Must release this in dealloc
          [theName release]; // decrement the reference count because of retain
      }

Should I call retain here so that I own the argument temporarily and ensure it doesnt’
get released somehow before I get to use it?

Any help would be appreciated! Thanks!

Answer 1

No. You the object supplied as an argument to the method will generally be around until your method returns. You don’t need the retain messages there. You copy the string here to keep it around after the method returns.

This is documented in Apple’s Documentation on this page in the “Avoid Causing Deallocation of Objects You’re Using” Section. Specifically:

Cocoa’s ownership policy specifies that received objects should
typically remain valid throughout the scope of the calling method. It
should also be possible to return a received object from the current
scope without fear of it being released. It should not matter to your
application that the getter method of an object returns a cached
instance variable or a computed value. What matters is that the object
remains valid for the time you need it.

As an aside you really should consider using ARC. Its not good practise to manage your own memory. No matter how good one can be at managing their own memory the LLVM compiler is still better. Managing your own memory will lead to hard to troubleshoot issues caused only by yourself. It is an extra level of cognitive load that you really don’t have to deal with and, when you finally let manual memory management go, you will breathe a sigh of relief at all the mental overhead you didn’t even know was there.