Objective-C Fundamentals

80 CHAPTER 4 Storing data in collections
Notice that at no point do you specify in which order you want to step through the array.
This logic is inherently built into the particular NSEnumerator instance you obtain. Different
versions of NSEnumerator may step through the sequence in different orders.
As an example, try replacing the existing call to objectEnumerator with a call to
reverseObjectEnumerator. Both NSArray messages provide NSEnumerator instances,
but the enumerator provided by reverseObjectEnumerator steps through the array
in reverse order, starting at the last element and working toward the first.
Using an enumerator can be efficient because the NSEnumerator instance can keep
track of additional state about the internal structure of the object it’s enumerating, but
it’s not the only weapon available in Objective-C’s toolbox of performance tricks.
FAST ENUMERATION
As the name suggests, fast enumeration is a feature designed to make the process of
enumeration even faster and more efficient. It’s one part Objective-C language syntax
and one part runtime library support. For fast enumeration, you can use a special
form of the for statement:
NSEnumerator enumerator = [pets reverseObjectEnumerator];
for (NSString *pet in enumerator) {
NSLog(@"Next Pet: %@", pet);
}
The syntax is cleaner and more concise, but how does it work? In the brackets of the
for statement, you declare a new variable followed by the keyword in and the object
to which you want to apply fast enumeration. Each time through the loop, the for
statement assigns the next element in the enumeration to the specified variable.
Fast enumeration can be used with any NSEnumerator, and it can also be used
directly on an instance of the NSArray or NSMutableArray class. For example, the following
snippet also works and leads to some very clean code:
for (NSString *pet in pets) {
NSLog(@"Next Pet: %@", pet);
}
Fast enumeration can’t be used with every object, however. It requires the object that
is after the in keyword to implement the NSFastEnumeration protocol. Protocols are
discussed in detail in chapter 7.
4.1.5 Adding items to an array
If you create an instance of the NSArray class, the array is said to be immutable because
you can’t modify the structure or contents of the array after it’s been initially constructed.
If you attempt to modify an NSArray instance, you’ll get an exception message
such as the following listed to the Xcode debugger console, and your application
will crash:
*** Terminating app due to uncaught exception
'NSInternalInconsistencyException', reason: '*** - [NSCFArray
replaceObjectAtIndex:withObject:]: mutating method sent to immutable
object'