ARRAY-one dime

Overview

• An array is a collection of data items, all of the same type, accessed using a common name.
• A one-dimensional array is like a list;  A two dimensional array is like a table;  The C language places no limits on the number of dimensions in an array, though specific implementations may.
• Some texts refer to one-dimensional arrays as vectors, two-dimensional arrays as matrices, and use the general term arrays when the number of dimensions is unspecified or unimportant.

Declaring Arrays

• Array variables are declared identically to variables of their data type, except that the variable name is followed by one pair of square [ ] brackets for each dimension of the array.
• Uninitialized arrays must have the dimensions of their rows, columns, etc. listed within the square brackets.
• Dimensions used when declaring arrays in C must be positive integral constants or constant expressions.
• Examples:

        int i, j, intArray[ 10 ], number;
        float floatArray[ 1000 ];
        int tableArray[ 3 ][ 5 ];      /* 3 rows by 5 columns */
        
        const int NROWS = 100;      // ( Old code would use #define NROWS 100 )
        const int NCOLS = 200;      // ( Old code would use #define NCOLS 200 )
        float matrix[ NROWS ][ NCOLS ];

Initializing Arrays

• Arrays may be initialized when they are declared, just as any other variables.
• Place the initialization data in curly {} braces following the equals sign.  Note the use of commas in the examples below.
• An array may be partially initialized, by providing fewer data items than the size of the array.  The remaining array elements will be automatically initialized to zero.
• If an array is to be completely initialized, the dimension of the array is not required.  The compiler will automatically size the array to fit the initialized data.  ( Variation:  Multidimensional arrays - see below. )
• Examples:

        int i =  5, intArray[ 6 ] = { 1, 2, 3, 4, 5, 6 }, k;
        float sum  = 0.0f, floatArray[ 100 ] = { 1.0f, 5.0f, 20.0f };
        double  piFractions[ ] = { 3.141592654, 1.570796327, 0.785398163 };

Designated Initializers:

• This method can be mixed in with traditional initialization
• For example:

int numbers[ 100 ] = { 1, 2, 3,  10, 11, 12, 50, 420 };

• In this example,the first three elements are initialized to 1, 2, and 3 respectively.
• Then element 10 ( the 11th element ) is initialized to 10
• The next two elements ( 12th and 13th ) are initialized to 11 and 12 respectively.
• Element number 60 ( the 61st ) is initialized to 50, and number 42 ( the 43rd ) to 420.
  • ( Note that the designated initializers do not need to appear in order. )
• As with traditional methods, all uninitialized values are set to zero.
• If the size of the array is not given, then the largest initialized position determines the size of the array.

Using Arrays

• Elements of an array are accessed by specifying the index ( offset ) of the desired element within square [ ] brackets after the array name.
• Array subscripts must be of integer type.  ( int, long int, char, etc. )
• VERY IMPORTANT: Array indices start at zero in C, and go to one less than the size of the array.  For example, a five element array will have indices zero through four.  This is because the index in C is actually an offset from the beginning of the array.  ( The first element is at the beginning of the array, and hence has zero offset. )
• Landmine:  The most common mistake when working with arrays in C is forgetting that indices start at zero and stop one less than the array size.
• Arrays are commonly used in conjunction with loops, in order to perform the same calculations on all ( or some part ) of  the data items in the array.

Sample Programs Using 1-D Arrays

• The first sample program uses loops and arrays to calculate the first twenty Fibonacci numbers.  Fibonacci numbers are used to determine the sample points used in certain optimization methods.

        /* Program to calculate the first 20 Fibonacci numbers. */
        
        #include <conio.h>
        #include <stdio.h> 

        int main( void ) {
            
            int i, fibonacci[ 20 ];
            
            Fibonacci[ 0 ] = 0;
            fibonacci[ 1 ] = 1;
            
            for( i = 2; i < 20; i++ )
                fibonacci[ i ] = fibonacci[ i - 2 ] + fibonacci[ i - 1 ];
                
            for( i = 0; i < 20; i++ )
                printf( "Fibonacci[ %d ] = %f\n", i, fibonacci[ i ] );
            
        } /* End of sample program to calculate Fibonacci numbers */  

• Exercise: What is the output of the following program:

        /* Sample Program Using Arrays */
        
        #include <stdlib.h>
        #include <stdio.h> 
        
        int main( void ) {
        
            int numbers[ 10 ];
            int i, index = 2;
            
            for( i = 0; i < 10; i++ ) 
                numbers[ i ] = i * 10;
            
            numbers[ 8 ] = 25;
            numbers[ 5 ] = numbers[ 9 ] / 3;
            numbers[ 4 ] += numbers[ 2 ] / numbers[ 1 ];
            numbers[ index ] = 5;
            ++numbers[ index ];
            numbers[ numbers[ index++ ] ] = 100;
            numbers[ index ] = numbers[ numbers[ index + 1 ] / 7 ]--;
            
            for( index = 0; index < 10; index++ )
                printf( "numbers[ %d ] = %d\n" index, numbers[ index ] );
            
        } /* End of second sample program */