Arrays in C

An array is a collection of similar elements. These similar elements could be all ints, or all floats, or all chars, etc. Usually, the array of characters is called a ‘string’, whereas an array of ints or floats is called simply an array. Remember that all elements of any given array must be of the same type. i.e. we cannot have an array of 10 numbers, of which 5 are ints and 5 are floats

A Simple Program Using Array

Let us try to write a program to find average marks obtained by a class of 30 students in a test.

main( ) 
{ 
 int avg, sum = 0 ; 
 int i ; 
 int marks[30] ; /* array declaration */ 
 for ( i = 0 ; i <= 29 ; i++ ) 
 { 
 printf ( "\nEnter marks " ) ; 
 scanf ( "%d", &marks[i] ) ; /* store data in array */ 
 } 
 for ( i = 0 ; i <= 29 ; i++ ) 
 sum = sum + marks[i] ; /* read data from an array*/ 
 avg = sum / 30 ; 
 printf ( "\nAverage marks = %d", avg ) ; 
} 

Array Declaration

To begin with, like other variables an array needs to be declared so that the compiler will know what kind of an array and how large an array we want. In our program we have done this with the statement

int marks[30] ;

Here, int specifies the type of the variable, just as it does with ordinary variables and the word marks specifies the name of the variable. The [30] however is new. The number 30 tells how many elements of the type int will be in our array. This number is often called the ‘dimension’ of the array. The bracket ( [ ] ) tells the compiler that we are dealing with an array.

Accessing Elements of an Array

Once an array is declared, let us see how individual elements in the array can be referred. This is done with subscript, the number in the brackets following the array name. This number specifies the element’s position in the array. All the array elements are numbered, starting with 0. Thus, marks[2] is not the second element of the array, but the third. In our program we are using the variable i as a subscript to refer to various elements of the array. This variable can take different values and hence can refer to the different elements in the array in turn. This ability to use variables as subscripts is what makes arrays so useful

Entering Data into an Array

Here is the section of code that places data into an array:

for ( i = 0 ; i <= 29 ; i++ ) 
{ 
 printf ( "\nEnter marks " ) ; 
 scanf ( "%d", &marks[i] ) ; 
}

Reading Data from an Array

for ( i = 0 ; i <= 29 ; i++ ) 
 sum = sum + marks[i] ; 
avg = sum / 30 ; 
printf ( "\nAverage marks = %d", avg ) ;

Array characteristics

• An array is a collection of similar elements.
• The first element in the array is numbered 0, so the last element is 1 less than the size of the array.
• An array is also known as a subscripted variable.
• Before using an array its type and dimension must be declared.
• However big an array its elements are always stored in contiguous memory locations. This is a very important point which we would discuss in more detail later on.

Array Initialisation

nt num[6] = { 2, 4, 12, 5, 45, 5 } ;
int n[ ] = { 2, 4, 12, 5, 45, 5 } ;
float press[ ] = { 12.3, 34.2 -23.4, -11.3 } ;

• Till the array elements are not given any specific values, they are supposed to contain garbage values.
• If the array is initialised where it is declared, mentioning the dimension of the array is optional

Array Elements in Memory

array declaration

int arr[8] ;

What happens in memory when we make this declaration ? 16 bytes get immediately reserved in memory, 2 bytes each for the 8 integers (under Windows/Linux the array would occupy 32 bytes as each integer would occupy 4 bytes). And since the array is not being initialized, all eight values present in it would be garbage values. This so happens because the storage class of this array is assumed to be auto. If the storage class is declared to be static then all the array elements would have a default initial value as zero. Whatever be the initial values, all the array elements would always be present in contiguous memory locations

Bounds Checking

In C there is no check to see if the subscript used for an array exceeds the size of the array. Data entered with a subscript exceeding the array size will simply be placed in memory outside the array; probably on top of other data, or on the program itself. This will lead to unpredictable results, to say the least, and there will be no error message to warn you that you are going beyond the array size. In some cases the computer may just hang

Passing Array Elements to a Function

Array elements can be passed to a function by calling the function by value, or by reference. In the call by value we pass values of array elements to the function, whereas in the call by reference we pass addresses of array elements to the function

/* Demonstration of call by value */

main( ) 
{ 
 int i ; 
 int marks[ ] = { 55, 65, 75, 56, 78, 78, 90 } ; 
 for ( i = 0 ; i <= 6 ; i++ ) 
 display ( marks[i] ) ; 
} 
display ( int m ) 
{ 
 printf ( "%d ", m ) ; 
} 

55 65 75 56 78 78 90

/* Demonstration of call by reference */

main( ) 
{ 
 int i ; 
 int marks[ ] = { 55, 65, 75, 56, 78, 78, 90 } ; 
 for ( i = 0 ; i <= 6 ; i++ ) 
 disp ( &marks[i] ) ; 
} 
disp ( int *n ) 
{ 
 printf ( "%d ", *n ) ; 
}

Output

55 65 75 56 78 78 90