Objective-C Fundamentals

Creating your own data types
49
With this statement, you’ve declared enough space to store 150 boxes but used only
one variable name, boxes, to identify them all. The number specified in square brackets
indicates the number of items that can be stored in the array.
To access the details of each box, you must provide the name of the array along
with the index value of the desired element. By convention, the first element in an
array has an index of 0, and each element thereafter has an increasing index value.
This means that the last entry in a 150-element array will be accessible via index 149.
The following statement will access and print the width of the sixth box:
NSLog(@"The 6th box has a width of %d inches", boxes[5].width);
Notice that to access the sixth element, you specified index 5. That’s because indexes
start at 0 and not the more “natural” value of 1. When accessing array elements, the
array index need not be specified as a simple constant. You can use any valid expression
that results in an integer value. This allows you to write code that accesses different
array items based on the state of the application. For example, consider the
following code sample, which adds the widths of all 150 boxes:
int totalWidth = 0;
for (int i = 0; i < 150; i++) {
totalWidth = totalWidth + boxes[i].width;
}
This example uses a for loop to repeat the statement totalWidth = totalWidth +
boxes[i].width with the value of variable i incrementing between 0 and 149. Contrasting
this expression with the one mentioned toward the end of section 2.4.2, you
can see that this version can easily be updated to cope with different numbers of
boxes by changing the value 150 in the second line. Using an array in this scenario
makes for an easier and vastly more maintainable solution.
INITIALIZING ARRAYS
When declaring array variables, it can be helpful to provide each element in the array
with an initial value. To do so, place a comma-separated list of initial values in a set of
curly braces, similar to how structures are initialized:
int count1[5] = { 10, 20, 30, 40, 50 };
int count2[] = { 10, 20, 30, 40, 50 };
This code snippet creates two integer arrays with five elements. In each array, the first
element stores the value 10, the second element stores 20, and so on.
In the first array, the array is explicitly sized to store five elements. It’s an error to
provide more initialization values than the size of the array, but if fewer are provided,
any uninitialized elements at the end of the array will be set to zero.
The second array demonstrates that when initializing an array, it’s possible to omit
its size. In this scenario, the C compiler infers the size from the number of initialization
values provided.