Sparrow Forum

1. 

   menehune17
   Member

   Hello, I am fairly new to Obj-C and Sparrow. I have noticed some strange behavior and would like to know if anyone can explain it:

   I have a class, called TitleScreen that has a "@property m" statement in the interface and "@synthesize m" in the implementation.

   In my TitleScreen init method, I can initialize the "m" property in 2 ways:

   1:
   

   m = [SPImage imageWithContentsOfFile:@"M.png"];
   // retainCount is now 1

   and 2:
   

   self.m = [SPImage imageWithContentsOfFile:@"M.png"];
   // retainCount is now 2

   I understand the differences between directly accessing the m property without "self", and using the synthesized method by calling "self.m = ..." (as in #2), and so I prefer #2 because the synthesized methods are "safer".

   However, I do not understand why the retainCount is different for each case. Any ideas?

   THANKS AHEAD OF TIME!

   Posted 9 months ago #
2. 

   Shilo
   Master Sparrow

   Hello,

   This is a little difficult to explain. I will start with factory methods. When you use a factory method such as "imageWithContentsOfFile:", it is actually doing:

   m = [[[SPImage alloc] initWithContentsOfFile:@"M.png"] autorelease];

   When this happens, it will show a retainCount of 1 for the current run loop/cycle. Then on the next loop, the object will be auto released. Thus the retainCount will be 0. (Note: NSLogging a retainCount of 0 will crash the app). Factory methods come in handy when you just need to add the image directly to the stage. When the image is added to an SPDisplayObjectContainer, it will be retained by that container.

   Now, when you add a declare a property like:

   @property m;

   What is really happening is:

   @property (atomic, retain) m;

   (Note: it is either "atomic" or "nonatomic", I can't remember which is default)
   Atomic/nonatomic has to do with threading, but don't worry about that for now. Notice how the second keyword is "retain". When assigning a variable with the property (such as "self.m"), it will retain that object. So for example, it's like doing this:

   m = [[SPImage imageWithContentsOfFile:@"M.png"] retain];

   Which will result in a retainCount of 2 for the current run cycle, then on the next run cycle, it will be autoreleased once, then it will have a retainCount of 1.

   Retaining objects is more safe to a point, since it won't cause a crash when trying to access an object that was autoreleased. But you should also be careful and make sure to release retained objects when you are done using them, like within the "dealloc" method of your class.

   If you prefer to use "self.m" and retain the object, you can release it a few ways:
   1. Release the variable directly:

   [m release];

   2. Set the property to nil, which will autorelease the object in the setter method.

   self.m = nil;

   If you would rather use property methods without retaining the object at all. You can use "assign" in the keyword. Example:

   @property (nonatomic, assign) m;

   For more info about properties, you can read: http://www.raywenderlich.com/2712/using-properties-in-objective-c-tutorial
   I haven't read this tutorial, but Ray Wenderlich has a lot of great tutorials.

   I hope this makes sense, feel free to ask any more questions.

   Posted 9 months ago #
3. 

   menehune17
   Member

   Hi Shilo, thanks so much for the detailed response. You actually got to the point of my problem -- that the object was not being released. I did find that using
   

    self.m = nil

   versus:
   

   m = nil

   caused "m" to be deallocated.

   I think this is making more sense, thanks!

   Posted 9 months ago #
4. 

   menehune17
   Member

   One more thing, could you explain why the first case above works versus the second?

   Posted 9 months ago #
5. 

   Shilo
   Master Sparrow

   Like I mentioned above, using:

   self.m = nil;

   will autorelease the object in the setter method.

   If you were to do this instead:

   m = nil;

   It will not autorelease the object, instead it just sets the variable to "nil" which means the variable will not be pointing towards that object (memory location) anymore, and will cause a memory leak.

   What really goes on inside the @synthesized setter method is similar to this:

   - (void)setM:(SPImage *)mValue {
       [m autorelease];
       m = [mValue retain];
   }

   Posted 9 months ago #

RSS feed for this topic

Reply

You must log in to post.