Objective-C Defines Additional Primitive Types

The BOOL scalar type is defined in Objective-C to hold a Boolean value, which is either YES or NO. As you might expect, YES is logically equivalent to true and 1, while NO is equivalent to false and 0.

Many parameters to methods on Cocoa and Cocoa Touch objects also use special scalar numeric types, such as NSInteger or CGFloat.

For example, the NSTableViewDataSource and UITableViewDataSource protocols (described in the previous chapter) both have methods requesting the number of rows to display:

@protocol NSTableViewDataSource <NSObject>

- (NSInteger)numberOfRowsInTableView:(NSTableView *)tableView;

...

@end

These types, like NSInteger and NSUInteger, are defined differently depending on the target architecture. When building for a 32-bit environment (such as for iOS), they are 32-bit signed and unsigned integers respectively; when building for a 64-bit environment (such as for the modern OS X runtime) they are 64-bit signed and unsigned integers respectively.

It’s best practice to use these platform-specific types if you might be passing values across API boundaries (both internal and exported APIs), such as arguments or return values in method or function calls between your application code and a framework.

For local variables, such as a counter in a loop, it’s fine to use the basic C types if you know that the value is within the standard limits.

C Structures Can Hold Primitive Values

Some Cocoa and Cocoa Touch API use C structures to hold their values. As an example, it’s possible to ask a string object for the range of a substring, like this:

    NSString *mainString = @"This is a long string";

    NSRange substringRange = [mainString rangeOfString:@"long"];

An NSRange structure holds a location and a length. In this case, substringRange will hold a range of {10,4}—the “l” at the start of @"long" is the character at zero-based index 10 in mainString, and @"long" is 4 characters in length.

Similarly, if you need to write custom drawing code, you’ll need to interact with Quartz, which requires structures based around the CGFloat data type, like NSPoint and NSSize on OS X and CGPoint and CGSize on iOS. Again, CGFloat is defined differently depending on the target architecture.

For more information on the Quartz 2D drawing engine, see Quartz 2D Programming Guide.

Strings Are Represented by Instances of the NSString Class

As you’ve seen in the previous chapters, NSString is used to represent a string of characters, like Hello World. There are various ways to create NSString objects, including standard allocation and initialization, class factory methods or literal syntax:

    NSString *firstString = [[NSString alloc] initWithCString:"Hello World!"

                                                     encoding:NSUTF8StringEncoding];

    NSString *secondString = [NSString stringWithCString:"Hello World!"

                                                encoding:NSUTF8StringEncoding];

    NSString *thirdString = @"Hello World!";

Each of these examples effectively accomplishes the same thing—creating a string object that represents the provided characters.

The basic NSString class is immutable, which means its contents are set at creation and cannot later be changed. If you need to represent a different string, you must create a new string object, like this:

    NSString *name = @"John";

    name = [name stringByAppendingString:@"ny"];    // returns a new string object

The NSMutableString class is the mutable subclass of NSString, and allows you to change its character contents at runtime using methods like appendString: or appendFormat:, like this:

    NSMutableString *name = [NSMutableString stringWithString:@"John"];

    [name appendString:@"ny"];   // same object, but now represents "Johnny"

    int magicNumber = ...

    NSString *magicString = [NSString stringWithFormat:@"The magic number is %i", magicNumber];

Numbers Are Represented by Instances of the NSNumber Class

The NSNumber class is used to represent any of the basic C scalar types, including char, double, float, int, long, short, and the unsigned variants of each, as well as the Objective-C Boolean type, BOOL.

As with NSString, you have a variety of options to create NSNumber instances, including allocation and initialization or the class factory methods:

    NSNumber *magicNumber = [[NSNumber alloc] initWithInt:42];

    NSNumber *unsignedNumber = [[NSNumber alloc] initWithUnsignedInt:42u];

    NSNumber *longNumber = [[NSNumber alloc] initWithLong:42l];

    NSNumber *boolNumber = [[NSNumber alloc] initWithBOOL:YES];

    NSNumber *simpleFloat = [NSNumber numberWithFloat:3.14f];

    NSNumber *betterDouble = [NSNumber numberWithDouble:3.1415926535];

    NSNumber *someChar = [NSNumber numberWithChar:'T'];

It’s also possible to create NSNumber instances using Objective-C literal syntax:

    NSNumber *magicNumber = @42;

    NSNumber *unsignedNumber = @42u;

    NSNumber *longNumber = @42l;

    NSNumber *boolNumber = @YES;

    NSNumber *simpleFloat = @3.14f;

    NSNumber *betterDouble = @3.1415926535;

    NSNumber *someChar = @'T';

These examples are equivalent to using the NSNumber class factory methods.

Once you’ve created an NSNumber instance it’s possible to request the scalar value using one of the accessor methods:

    int scalarMagic = [magicNumber intValue];

    unsigned int scalarUnsigned = [unsignedNumber unsignedIntValue];

    long scalarLong = [longNumber longValue];

    BOOL scalarBool = [boolNumber boolValue];

    float scalarSimpleFloat = [simpleFloat floatValue];

    double scalarBetterDouble = [betterDouble doubleValue];

    char scalarChar = [someChar charValue];

The NSNumber class also offers methods to work with the additional Objective-C primitive types. If you need to create an object representation of the scalar NSInteger and NSUInteger types, for example, make sure you use the correct methods:

    NSInteger anInteger = 64;

    NSUInteger anUnsignedInteger = 100;

    NSNumber *firstInteger = [[NSNumber alloc] initWithInteger:anInteger];

    NSNumber *secondInteger = [NSNumber numberWithUnsignedInteger:anUnsignedInteger];

    NSInteger integerCheck = [firstInteger integerValue];

    NSUInteger unsignedCheck = [secondInteger unsignedIntegerValue];

All NSNumber instances are immutable, and there is no mutable subclass; if you need a different number, simply use another NSNumber instance.

Represent Other Values Using Instances of the NSValue Class

The NSNumber class is itself a subclass of the basic NSValue class, which provides an object wrapper around a single value or data item. In addition to the basic C scalar types, NSValue can also be used to represent pointers and structures.

The NSValue class offers various factory methods to create a value with a given standard structure, which makes it easy to create an instance to represent, for example, an NSRange, like the example from earlier in the chapter:

    NSString *mainString = @"This is a long string";

    NSRange substringRange = [mainString rangeOfString:@"long"];

    NSValue *rangeValue = [NSValue valueWithRange:substringRange];

It’s also possible to create NSValue objects to represent custom structures. If you have a particular need to use a C structure (rather than an Objective-C object) to store information, like this:

typedef struct {

    int i;

    float f;

} MyIntegerFloatStruct;

you can create an NSValue instance by providing a pointer to the structure as well as an encoded Objective-C type. The @encode() compiler directive is used to create the correct Objective-C type, like this:

    struct MyIntegerFloatStruct aStruct;

    aStruct.i = 42;

    aStruct.f = 3.14;

    NSValue *structValue = [NSValue value:&aStruct

                             withObjCType:@encode(MyIntegerFloatStruct)];

The standard C reference operator (&) is used to provide the address of aStruct for the value parameter.

Arrays Are Ordered Collections

An NSArray is used to represent an ordered collection of objects. The only requirement is that each item is an Objective-C object— there’s no requirement for each object to be an instance of the same class.

To maintain order in the array, each element is stored at a zero-based index, as shown in Figure 6-1.

+ (id)arrayWithObject:(id)anObject;

+ (id)arrayWithObjects:(id)firstObject, ...;

- (id)initWithObjects:(id)firstObject, ...;

    NSArray *someArray =

  [NSArray arrayWithObjects:someObject, someString, someNumber, someValue, nil];

    id firstObject = @"someString";

    id secondObject = nil;

    id thirdObject = @"anotherString";

    NSArray *someArray =

  [NSArray arrayWithObjects:firstObject, secondObject, thirdObject, nil];

    NSArray *someArray = @[firstObject, secondObject, thirdObject];

    id firstObject = @"someString";

    id secondObject = nil;

    NSArray *someArray = @[firstObject, secondObject];

    // exception: "attempt to insert nil object"

    NSUInteger numberOfItems = [someArray count];

    if ([someArray containsObject:someString]) {

        ...

    }

    if ([someArray count] > 0) {

        NSLog(@"First item is: %@", [someArray objectAtIndex:0]);

    }

    if ([someArray count] > 0) {

        NSLog(@"First item is: %@", someArray[0]);

    }

    NSArray *unsortedStrings = @[@"gammaString", @"alphaString", @"betaString"];

    NSArray *sortedStrings =

                 [unsortedStrings sortedArrayUsingSelector:@selector(compare:)];

NSMutableString *mutableString = [NSMutableString stringWithString:@"Hello"];

NSArray *immutableArray = @[mutableString];

    if ([immutableArray count] > 0) {

        id string = immutableArray[0];

        if ([string isKindOfClass:[NSMutableString class]]) {

            [string appendString:@" World!"];

        }

    }

    NSMutableArray *mutableArray = [NSMutableArray array];

    [mutableArray addObject:@"gamma"];

    [mutableArray addObject:@"alpha"];

    [mutableArray addObject:@"beta"];

    [mutableArray replaceObjectAtIndex:0 withObject:@"epsilon"];

    [mutableArray sortUsingSelector:@selector(caseInsensitiveCompare:)];

Sets Are Unordered Collections

An NSSet is similar to an array, but maintains an unordered group of distinct objects, as shown in Figure 6-2.

Because sets don’t maintain order, they offer a performance improvement over arrays when it comes to testing for membership.

The basic NSSet class is again immutable, so its contents must be specified at creation, using either allocation and initialization or a class factory method, like this:

    NSSet *simpleSet =

      [NSSet setWithObjects:@"Hello, World!", @42, aValue, anObject, nil];

As with NSArray, the initWithObjects: and setWithObjects: methods both take a nil-terminated, variable number of arguments. The mutable NSSet subclass is NSMutableSet.

Sets only store one reference to an individual object, even if you try and add an object more than once:

    NSNumber *number = @42;

    NSSet *numberSet =

      [NSSet setWithObjects:number, number, number, number, nil];

    // numberSet only contains one object

For more information on sets, see Sets: Unordered Collections of Objects.

Dictionaries Collect Key-Value Pairs

Rather than simply maintaining an ordered or unordered collection of objects, an NSDictionary stores objects against given keys, which can then be used for retrieval.

It’s best practice to use string objects as dictionary keys, as shown in Figure 6-3.

    NSDictionary *dictionary = [NSDictionary dictionaryWithObjectsAndKeys:

                   someObject, @"anObject",

             @"Hello, World!", @"helloString",

                          @42, @"magicNumber",

                    someValue, @"aValue",

                             nil];

    NSDictionary *dictionary = @{

                  @"anObject" : someObject,

               @"helloString" : @"Hello, World!",

               @"magicNumber" : @42,

                    @"aValue" : someValue

    };

    NSNumber *storedNumber = [dictionary objectForKey:@"magicNumber"];

    NSNumber *storedNumber = dictionary[@"magicNumber"];

    [dictionary setObject:@"another string" forKey:@"secondString"];

    [dictionary removeObjectForKey:@"anObject"];

Represent nil with NSNull

It’s not possible to add nil to the collection classes described in this section because nil in Objective-C means “no object.” If you need to represent “no object” in a collection, you can use the NSNull class:

    NSArray *array = @[ @"string", @42, [NSNull null] ];

NSNull is a singleton class, which means that the null method will always return the same instance. This means that you can check whether an object in an array is equal to the shared NSNull instance:

    for (id object in array) {

        if (object == [NSNull null]) {

            NSLog(@"Found a null object");

        }

    }

Fast Enumeration Makes It Easy to Enumerate a Collection

Many collection classes conform to the NSFastEnumeration protocol, including NSArray, NSSet and NSDictionary. This means that you can use fast enumeration, an Objective-C language-level feature.

The fast enumeration syntax to enumerate the contents of an array or set looks like this:

    for (<Type> <variable> in <collection>) {

        ...

    }

As an example, you might use fast enumeration to log a description of each object in an array, like this:

    for (id eachObject in array) {

        NSLog(@"Object: %@", eachObject);

    }

The eachObject variable is set automatically to the current object for each pass through the loop, so one log statement appears per object.

If you use fast enumeration with a dictionary, you iterate over the dictionary keys, like this:

    for (NSString *eachKey in dictionary) {

        id object = dictionary[eachKey];

        NSLog(@"Object: %@ for key: %@", object, eachKey);

    }

Fast enumeration behaves much like a standard C for loop, so you can use the break keyword to interrupt the iteration, or continue to advance to the next element.

If you are enumerating an ordered collection, the enumeration proceeds in that order. For an NSArray, this means the first pass will be for the object at index 0, the second for object at index 1, etc. If you need to keep track of the current index, simply count the iterations as they occur:

    int index = 0;

    for (id eachObject in array) {

        NSLog(@"Object at index %i is: %@", index, eachObject);

        index++;

    }

You cannot mutate a collection during fast enumeration, even if the collection is mutable. If you attempt to add or remove a collected object from within the loop, you’ll generate a runtime exception.

Most Collections Also Support Enumerator Objects

It’s also possible to enumerate many Cocoa and Cocoa Touch collections by using an NSEnumerator object.

You can ask an NSArray, for example, for an objectEnumerator or a reverseObjectEnumerator. It’s possible to use these objects with fast enumeration, like this:

    for (id eachObject in [array reverseObjectEnumerator]) {

        ...

    }

In this example, the loop will iterate over the collected objects in reverse order, so the last object will be first, and so on.

It’s also possible to iterate through the contents by calling the enumerator’s nextObject method repeatedly, like this:

    id eachObject;

    while ( (eachObject = [enumerator nextObject]) ) {

        NSLog(@"Current object is: %@", eachObject);

    }

In this example, a while loop is used to set the eachObject variable to the next object for each pass through the loop. When there are no more objects left, the nextObject method will return nil, which evaluates as a logical value of false so the loop stops.

As with fast enumeration, you cannot mutate a collection while enumerating. And, as you might gather from the name, it’s faster to use fast enumeration than to use an enumerator object manually.

Many Collections Support Block-Based Enumeration

It’s also possible to enumerate NSArray, NSSet and NSDictionary using blocks. Blocks are covered in detail in the next chapter.