Objective-C Fundamentals

88 CHAPTER 4 Storing data in collections
create a snapshot of the dictionary’s keys and then enumerate through the snapshot
while modifying the original dictionary. Here’s an example of this process:
NSArray *myKeys = [myDetails allKeys];
for (NSString *key in myKeys) {
[myDetails removeObjectForKey:key];
}
This works because the allKeys message creates a copy of the keys in the myDetails
dictionary. The enumerator then loops through the contents of the array (and not the
dictionary). Because the array is never modified, it’s safe to enumerate its contents.
Each time through the loop, you modify the dictionary, indirectly causing its internal
data structures to change. This doesn’t matter, however, because technically you’re
not currently enumerating its contents.
While discussing arrays and dictionaries, we casually mentioned that various messages
won’t accept nil or that they use nil to indicate special conditions. We also
mentioned that these data structures are only capable of storing objects, not primitive
values such as integer or float. But most applications need to store a list of numbers,
so how can you force an NSArray or NSDictionary instance to store a set of primitive
values? The answer is a technique called boxing.
4.3 Boxing
Undoubtedly in your application you’ll come across the need to store a number such
as 3, 4.86, or even a Boolean YES or NO value in an NSArray- or NSDictionary-based
data structure. You may think you could accomplish this task with a code snippet such
as the following:
[myArray addObject:5];
But when you attempt to compile this statement, the compiler will warn you that
"passing argument 1 of addObject: makes pointer from integer without a cast,"
hinting that something isn’t quite right. This example is a classic demonstration of the
procedural C-based side of Objective-C running up against the newer object-oriented
additions to the language.
Classes such as NSArray and NSDictionary expect their keys and values to be
objects of some kind. The integer number 5 isn’t an object: it’s a simple primitive data
type. As such, it’s not possible to directly store an integer in an array.
Many languages such as Java 5 and C# take care of this problem automatically
through a concept called autoboxing. Behind the scenes, the primitive (non-objectoriented)
value is wrapped inside a container object (a box), and this container is
passed around instead of the raw value. Likewise, when you attempt to access the array
and extract the value, the compiler detects a boxed value and automatically extracts
the primitive payload for you. You as a developer are none the wiser to this process
occurring. This process can be conceptualized in much the same way as a gift being
placed inside a FedEx box and removed once it reaches its destination. FedEx can
only deal with boxes of certain sizes, not your oddly shaped teapot for Aunt Betty, but