Arrays

ARRAYS

C programming language provides a data structure called the array, which can store a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.

Instead of declaring individual variables, such as number0, number1, ..., and number99, you declare one array variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to represent individual variables. A specific element in an array is accessed by an index.

All arrays consist of contiguous memory locations. The lowest address corresponds to the first element and the highest address to the last element.

Declaring Arrays

To declare an array in C, a programmer specifies the type of the elements and the number of elements required by an array as follows:

type arrayName [ arraySize ];

This is called a single-dimensional array. The arraySize must be an integer constant greater than zero and type can be any valid C data type. For example, to declare a 10-element array called balance of type double, use this statement:

double balance[10];

Now balance is avariable array which is sufficient to hold upto 10 double numbers.

Initializing Arrays

You can initialize array in C either one by one or using a single statement as follows:

double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};

The number of values between braces { } can not be larger than the number of elements that we declare for the array between square brackets [ ]. Following is an example to assign a single element of the array:

If you omit the size of the array, an array just big enough to hold the initialization is created. Therefore, if you write:

double balance[] = {1000.0, 2.0, 3.4, 17.0, 50.0};

You will create exactly the same array as you did in the previous example.

balance[4] = 50.0;

The above statement assigns element number 5th in the array a value of 50.0. Array with 4th index will be 5th ie. last element because all arrays have 0 as the index of their first element which is also called base index. Following is the pictorial representation of the same array we discussed above:

Accessing Array Elements

An element is accessed by indexing the array name. This is done by placing the index of the element within square brackets after the name of the array. For example:

double salary = balance[9];

The above statement will take 10th element from the array and assign the value to salary variable. Following is an example which will use all the above mentioned three concepts viz. declaration, assignment and accessing arrays:

#include <stdio.h> int main ()

{

int n[ 10 ]; /* n is an array of 10 integers */ int i,j;

/* initialize elements of array n to 0 */ for ( i = 0; i < 10; i++ )

{

n[ i ] = i + 100; /* set element at location i to i + 100 */

}

/* output each array element's value

*/ for (j = 0; j < 10; j++ )

{

printf("Element[%d] = %d\n", j, n[j] );

}

return 0;

}

When the above code is compiled and executed, it produces the following result:

Element[0] = 100

Element[1] = 101

Element[2] = 102

Element[3] = 103

Element[4] = 104

Element[5] = 105

Element[6] = 106

Element[7] = 107

Element[8] = 108

Element[9] = 109

C Arrays in Detail

Arrays are important to C and should need lots of more details. There are following few important concepts related to array which should be clear to a C programmer:

Concept Vs Description

Multi-dimensional arrays

          C supports multidimensional arrays. The simplest form of the multidimensional array is the two-dimensional array.     

Passing arrays to functions

          You can pass to the function a pointer to an array by specifying the array's name without an index.

Return array from a function

          C allows a function to return an array.      

Pointer to an array

          You can generate a pointer to the first element of an array by simply specifying the array name, without any index.       

Multidimensional Array

Arrays of Arrays (``Multidimensional'' Arrays)

When we said that ``Arrays are not limited to type int; you can have arrays of... any other type,'' we meant that more literally than you might have guessed. If you have an ``array of int,'' it means that you have an array each of whose elements is of type int. But you can have an array each of whose elements is of type x, where x is any type you choose. In particular, you can have an array each of whose elements is another array! We can use these arrays of arrays for the same sorts of tasks as we'd use multidimensional arrays in other computer languages (or matrices in mathematics). Naturally, we are not limited to arrays of arrays, either; we could have an array of arrays of arrays, which would act like a 3-dimensional array, etc.

The declaration of an array of arrays looks like this:

int a2[5][7];

You have to read complicated declarations like these ``inside out.'' What this one says is that a2 is an array of 5 somethings, and that each of the somethings is an array of 7 ints. More briefly, ``a2 is an array of 5 arrays of 7 ints,'' or, ``a2 is an array of array of int.'' In the declaration of a2, the brackets closest to the identifier a2 tell you what a2 first and foremost is. That's how you know it's an array of 5 arrays of size 7, not the other way around. You can think of a2 as having 5 ``rows'' and 7 ``columns,'' although this interpretation is not mandatory. (You could also treat the ``first'' or inner subscript as ``x'' and the second as ``y.'' Unless you're doing something fancy, all you have to worry about is that the subscripts when you access the array match those that you used when you declared it, as in the examples below.)

To illustrate the use of multidimensional arrays, we might fill in the elements of the above array a2 using this piece of code:

int i, j;

for(i = 0; i < 5; i = i + 1)

{

for(j = 0; j < 7; j = j + 1) a2[i][j] = 10 * i + j;

}

This pair of nested loops sets a[1][2] to 12, a[4][1] to 41, etc. Since the first dimension of a2 is 5, the first subscripting index variable, i, runs from 0 to 4. Similarly, the second subscript varies from 0 to 6. We could print a2 out (in a two-dimensional way, suggesting its structure) with a similar pair of nested loops:

for(i = 0; i < 5; i = i + 1)

{

for(j = 0; j < 7; j = j + 1) printf("%d\t", a2[i][j]);

printf("\n");

}

(The character \t in the printf string is the tab character.)

Just to see more clearly what's going on, we could make the ``row'' and ``column'' subscripts explicit by printing them, too:

for(j = 0; j < 7; j = j + 1)

printf("\t%d:", j); printf("\n");

for(i = 0; i < 5; i = i + 1)

{

printf("%d:", i);

for(j = 0; j < 7; j = j + 1) printf("\t%d", a2[i][j]);

printf("\n");

}

This last fragment would print

          0:       1:       2:       3:       4:       5:       6:      

0:       0        1        2        3        4        5        6       

1:       10      11      12               13      14      15      16

2:       20      21      22               23      24      25      26

3:       30      31      32               33      34      35      36

4:       40      41      42               43      44      45      46

Finally, there's no reason we have to loop over the ``rows'' first and the ``columns'' second; depending on what we wanted to do, we could interchange the two loops, like this:

for(j = 0; j < 7; j = j + 1)

{

for(i = 0; i < 5; i = i + 1) printf("%d\t", a2[i][j]);

printf("\n");

}

Notice that i is still the first subscript and it still runs from 0 to 4, and j is still the second subscript and it still runs from 0 to 6.