Objective-C Fundamentals

Creating your own data types
45
With what we’ve covered so far, the best approach to store such values would be to
use an integer variable and to assign each state a unique value. For example, a value of 1
could indicate the compass was pointing North, whereas a value of 2 could indicate it
was pointing East. As a human, however, it can be rather tricky to manage this because
you don’t tend to think in terms of numbers. Seeing a variable set to the value 2, you
don’t immediately think “East.” Objective-C has a custom data type called an enumeration
that’s designed to resolve this.
To define a new enumerated data type, you use the special keyword enum. This is
followed by a name and a list of possible values in curly braces. For example, you
could declare an enumerated data type to store compass directions as follows:
enum direction { North, South, East, West };
Once the new enumeration data type is declared, you can create a variable of type
enum direction and assign it the value North, as shown here:
enum direction currentHeading = North;
You may wonder what integer value North represents because you didn’t explicitly specify
this during the declaration of the enumerated data type. By default, the first enumerated
value (North) is given the integer value 0, and each value thereafter is given a
value one greater than the name that preceded it. This convention can be overridden
when the enumeration is declared. As an example, with the following declaration:
enum direction { North, South = 10, East, West };
North has the value 0 because it’s the first enumerated value. South has the value 10
because it’s explicitly specified via an initializer, and East and West have the values 11
and 12 respectively because they immediately follow South. It’s even possible for more
than one name to map to the same integer value, although in this case there’s no way
to tell the two values apart.
In theory, an enumerated data type should be used to store only one of the values
specified in the enumeration. Unfortunately, Objective-C won’t generate a warning if
this rule is violated. As an example, the following is perfectly valid in an Objective-C
program and in many cases won’t produce a compilation error or warning:
enum direction currentHeading = 99;
Even if this is possible, you shouldn’t rely on it. Try to restrict yourself to storing and
comparing only the symbolic names you specified in the type declaration. Doing so
allows you to easily change the values in a single place and have confidence that all
logic in your application is correctly updated. If you make assumptions based on the
value of an enumerated data type (or store random integer values), you defeat one of
their main benefits, which is the association of a symbolic name to a specific value.
The association of integer value and symbolic name has a number of benefits,
including an improved debugging experience, as can be seen in figure 2.4.