Chapter 9: C Arrays
9.0 Declaring Arrays
9.1 Initializing Arrays
9.2 Accessing Array Elements
9.3 Input and Output Array Elements
9.4 Access elements out of its bound!
9.5 Multi-dimensional Arrays
9.6 Two-Dimensional Arrays
9.7 Initializing Two-Dimensional Arrays
9.8 Accessing Two-Dimensional Array Elements
9.9 Passing Arrays as Function Arguments
Array is a kind of data structure that 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.
9.0 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];
Here balance is a variable array which is sufficient to hold up to 10
double numbers.
9.1 Initializing Arrays
You can initialize an array in C either one by one or using a single
statement as follows −
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
The number of values between braces { } cannot be larger than the
number of elements that we declare for the array between square
brackets [ ].
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, 7.0, 50.0};
You will create exactly the same array as you did in the previous
example. Following is an example to assign a single element of the
array −
balance[4] = 50.0;
The above statement assigns the 5 th element in the array with a value
of 50.0. All arrays have 0 as the index of their first element which is
also called the base index and the last index of an array will be total
size of the array minus 1. Shown below is the pictorial representation of
the array we discussed above −
9.2 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 the 10 th element from the array and
assign the value to salary variable. The following example Shows how
to use all the three above mentioned concepts viz. declaration,
assignment, and accessing arrays
Few keynotes:
Arrays have 0 as the first index, not 1. In this example, mark[0] is the
first element.
If the size of an array is n , to access the last element, the n-1 index is
used. In this example, mark[4]
Suppose the starting address of mark[0] is 2120d. Then, the address of
the mark[1] will be 2124d. Similarly, the address of mark[2] will
be 2128d and so on.
This is because the size of a float is 4 bytes.
Use of arrays example
#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
9.3 Input and Output Array Elements
Here's how you can take input from the user and store it in an array
element.
// take input and store it in the 3rd element
scanf("%d", &mark[2]);
// take input and store it in the ith element
scanf("%d", &mark[i-1]);
Here's how you can print an individual element of an array.
// print the first element of the array
printf("%d", mark[0]);
// print the third element of the array
printf("%d", mark[2]);
9.4 Access elements out of its bound!
Suppose you declared an array of 10 elements. Let's say,
int testArray[10];
You can access the array elements from testArray[0] to testArray[9] .
Now let's say if you try to access testArray[12] . The element is not
available. This may cause unexpected output (undefined behavior).
Sometimes you might get an error and some other time your program
may run correctly.
Hence, you should never access elements of an array outside of its
bound.
9.5 Multi-dimensional Arrays
C programming language allows multidimensional arrays. Here is the
general form of a multidimensional array declaration:
type name[size1][size2]...[sizeN];
For example, the following declaration creates a three dimensional 5 .
10 . 4 integer array:
int threedim[5][10][4];
9.6 Two-Dimensional Arrays
The simplest form of the multidimensional array is the two-
dimensional array. A two-dimensional array is, in essence, a list of one-
dimensional arrays. To declare a two-dimensional integer array of size x,
y you would write something as follows:
type arrayName [ x ][ y ];
Where type can be any valid C data type and arrayName will be a valid
C identifier. A two-dimensional array can be thought as a table which
will have x number of rows and y number of columns.
A 2-dimentional array a, which contains three rows and four columns
can be shown as below:
Thus, every element in array a is identified by an element name of the
form a[ i ][ j ], where a is the name of the array, and i and j are the
subscripts that uniquely identify each element in a.
9.7 Initializing Two-Dimensional Arrays
Multidimensional arrays may be initialized by specifying bracketed
values for each row. Following is an array with 3 rows and each row has
4 columns.
int a[3][4] = {
{0, 1, 2, 3} , /* initializers for row indexed by 0 */
{4, 5, 6, 7} , /* initializers for row indexed by 1 */
{8, 9, 10, 11} /* initializers for row indexed by 2 */
};
The nested braces, which indicate the intended row, are optional. The
following initialization is equivalent to previous example:
int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};
9.8 Accessing Two-Dimensional Array Elements
Elements in Two-Dimensional arrays are accessed using the row
indexes and column indexes. For example:
int x[2][1];
The above example represents the element present in third row and
second column.
Let us check below program where we have used nested loop to handle
a two dimensional array:
#include <stdio.h>
int main ()
{
/* an array with 5 rows and 2 columns*/
int a[5][2] = { {0,0}, {1,2}, {2,4}, {3,6},{4,8}};
int i, j;
/* output each array element's value */ a[
for ( i = 0; i < 5; i++ ) 4
{ ]
for ( j = 0; j < 2; j++ ) [
{ 0
printf("a[%d][%d] = %d\n", i,j, a[i][j] ); ]:
} 4
} a[
return 0; 4
} ]
When the above code is compiled and executed, it produces the [
following 1
result: ]:
a[0][0]: 0 8
a[0][1]: 0
a[1][0]: 1 A
a[1][1]: 2 s
a[2][0]: 2 e
a[2][1]: 4 x
a[3][0]: 3 pl
a[3][1]: 6 ai
ned above, you can have arrays with any number of dimensions,
although it is likely that most of the arrays you create will be of one
or two dimensions.
9.9 Passing Arrays as Function Arguments
If you want to pass a single-dimension array as an argument in a function,
you would have to declare function formal parameter in one of following
three ways and all three declaration methods produce similar results
because each tells the compiler that an integer pointer is going to be
received. Similar way you can pass multi-dimensional array as formal
parameters.
Way-1
Formal parameters as a pointer as follows. You will study what is pointer in
next chapter.
void myFunction(int *param)
{
.
.
.
}
Way-2
Formal parameters as a sized array as follows:
void myFunction(int param[10])
{
.
.
.
}
Way-3
Formal parameters as an unsized array as follows:
void myFunction(int param[])
{
.
.
.
}
