Objective-C Fundamentals

180 CHAPTER 9 Memory management
The advantages of a reference counting–based memory management scheme include
the following:
■
■
Minimal overhead—Relatively little runtime support is required to implement
reference counting. This helps increase performance and reduce power consumption,
both of which are important on a mobile device.
Deterministic behavior—Because the developers are responsible for allocating
and releasing objects, they also have explicit control over exactly when and
where these events occur.
The potential disadvantages include the following:
■
■
Control implies responsibility—There’s a greater risk of the developer making
a mistake that will lead to memory leaks or random application crashes and
malfunctions.
Additional overhead—Including the developer in the memory management process
means there’s yet another item for developers to consider while developing
their applications rather than focusing on the core task of what makes their
application unique.
Now that you’re familiar with the concepts involved in reference counting–based
memory management, let’s look at how it’s implemented in Objective-C via the retain,
release, and autorelease messages and how to avoid memory leaks or the dreaded
"Program received signal: "EXC_BAD_ACCESS"." exception.
9.2.1 Releasing an object
When an owner of an object is finished using the object, it must tell the object that it
wants to give up ownership. This process reduces the internal reference count of the
object by one and is typically called releasing an object because the operation is performed
by sending the object a message called release, as demonstrated here:
NSMutableString *msg =
[[NSMutableString alloc] initWithString:@"Hello, world!"];
NSLog(@"The message is: %@", msg);
[msg release];
Because this code snippet creates the NSMutableString object (via the alloc message),
it inherently owns the string and must explicitly give up ownership when the
object becomes excess to requirements. This is achieved by the release message sent
to the object on the last line.
In this example, the release message also indirectly causes the Objective-C runtime
to send the object a dealloc message to destroy the object. This occurs because
the release message is releasing the last (and only) owner of the object. The object’s
retain count returns to zero when its last owner is released. If the object has more
than one owner, a call to release has no visible effect on the application, other than
to reduce the retain count, leaving the object with one less owner.
It’s important to note that once ownership of an object is given up, it’s generally
not safe to refer to or utilize that object again from the current section of code, even if