

Summary
• Introduction
• Arrays
• Initialization of Arrays
• Sample Program 1
• Copying Arrays
• Linear Search
• The Keyword ‘const’
• Tips
Page 104
Introduction
We have started writing functions, which will become a part of our every program.
As C
language is a functionoriented language, so we will be dealing with too many functions.
Our programming toolkit is almost complete but still a very important component
is
missing. We are going to discuss this component i.e. Arrays
in this lecture.
Let us consider an example about calculation of average age of 10 students. At first,
we
will declare 10 variables to store the age of each student and then sum up all the
ages and
divide this with 10 to get the average age. Suppose, we have 100 students instead
of 10,
we have to declare 100 variables i.e. one for each student’s age. Is there any other
way to
deal with this problem? Arrays are possible solution to the problem.
Array is a special datatype. If we have a collection of data of same type as in
the case of
storage of ages of 100 students, arrays can be used. Arrays are data structure in
which
identical data types are stored. The concept of arrays is being explained further
in the
following parts of the lecture.
Arrays
In C language, every array has a data type i.e. name and size. Data type can be
any valid
data type. The rules of variable naming convention apply to array names. The size
of the
array tells how many elements are there in the array. The size of the array should
be a
precise number. The arrays occupy the memory depending upon their size and have
contiguous area of memory. We can access the arrays using the array index.
Declaration:
The declaration of arrays is as follows:
data_type array_name [size] ;
for example:
int ages[10];
Let's consider an array int C[10]; This is an array of integer and has a name ’C'.
It has a
size ten which depicts that the array ‘C’ can contain ten elements of int data type.
In the
memory, the array occupies the contiguous area, in this case it will occupy forty
bytes
(one int = 4 bytes). The elements of the array are manipulated using the index.
In C
language, the index of array starts from zero and is one less than array's size.
Index of
array is also called subscript.
Memory image of an array:
Name
Page 105
In the above figure, the memory chunk containing the array C is shown. On the first
line,
C[0] is written while on the 2nd line, C[1] is written and so on.
The number in the [ ] is
the index of the array. C[0] is used for the first element, followed by C[1] for
the second
element and so on. It is important to note that in an array the index 6 ([6]) means
the
seventh element of the array and thus the eighth element will have an index 7. Thus,
the
index of the last element of the array will be 1 less than the size of the array.
On the right
hand side, the values of the elements are shown in the memory i.e. the value of
the
element at zero position ( C[0] ) is 24 while that of the element at first position
( C[1] ) is
59 and so on. The important thing to be noted here is that the indexing of the array
starts
from zero, not from one. So in the above example, the index of the array C will
be from
C[0] to C[9]. If we have an array of size 25, its index will be from 0 to 24.
Usage of Arrays
To declare arrays, we have to give their data type, name and size. These are fixedsize
arrays. In the coming lectures, we will discuss arrays without using size at declaration
time. Arrays may be declared with simple variables in a single line.
int i, age [10];
int height [10], length [10] ;
To access array, we can’t use the whole array at a time. We access arrays element
by
element. An index (subscript) may be used to access the first element of the array.
In this
case, to access first element we write like age[0]. To access the 5th
element, we will write
age[4] and so on. Using the index mechanism, we can use the array elements as simple
variables. Their use can be anywhere where there we can use a simple variable i.e.
in
C[0]
C[1]
C[2]
C[3]
Index
C [7 ]
C[8]
C[9]
...
35
59
24
..
..
..
..
...
…
Memory
Page 106
assignment statements, expressions etc. Please do not confuse the usage of array
and
declaration of array. When we write int age [10], it means we are declaring an array
of
type int, its name is age and its size is 10. When we write age[5], it means we
are
referring to the single element of the array not the whole array.
Consider the example of student’s ages again. Is there a way to calculate the average
age
of all the students in an array?
As we know that arrays can be accessed with indexing. So we can use a 'for
loop' as
under;
for (i = 0 ; i < 10 ; i++ )
{
cout << “Please enter the age of the student “;
cin >> age [i];
}
In the above 'for loop'
the value of i is
changing from 0 to 9. Here the loop condition is
i<10. This means that the
cin and
cout statements will be
executed 10 times. We have
used i as the index
of the array. The index we are referring to the array needs to be an
integer. It can be 4, 5 or an integer variable like
i. In the first repetition,
the value of i is
0,
i.e. age[0] so the
value of first element of the age will be read.
In the second repetition,
the value of i becomes
1 i.e. age[1] so
the value of 2nd element of the age will be read and
so on. We get all the 10 values from the user which will be stored in the array
age.
Now we will calculate the total of ages. We can use another 'for
loop' to add up all the
elements of the array age.
int totalAge = 0;
for (i = 0 ; i < 10 ; i++ )
{
totalAge += age [i];
}
In the above loop, all the elements of the array age will be added to the variable
totalAge.
When the value of i
is 0 i.e. age[0]
the value of first element will be added to the
totalAge. As the value of
i is changing from 0 to
9 so all the 10 elements of the array will
be added to the totalAge.
By dividing this totalAge
by 10 we will get the average age.
Initialization of Arrays
There are many ways to initialize an array. Don't use the default initialization
of arrays.
Compiler may assign some value to each declared array. Always initialize the array
in
such a manner that the process is clear.
We can initialize an array using a 'loop' while assigning some value.
Page 107
int i, age [10];
for ( i = 0; i < 10 ; i++ )
{
age[i] = 0;
}
With the help of this simple loop, we have initialized all the elements of array
age to
zero. In the loop condition, we have used the condition
i < 10, where the size
of the array
is ten. As we know, the array index is one less than the size of the array. Here
we are
using i as the index
of array and its values are from 0 to 9.
We can also initialize the array at the time of declaration as:
int age [10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
The above statement creates an array
age of integers and initializes
all the elements with
zero. We can use any value to initialize the array by using any other number instead
of
zero. However, generally, zero is used to initialize the integer variables.
We can do it by using the following shortcut.
int age [10] = { 0 };
The above statement has also initialized all the elements of the array to zero.
We have different ways of initializing the arrays. Initialization through the use
of loop is
a better choice. If the size of the array gets larger, it is tedious to initialize
at the
declaration time.
Consider the following statement:
int age [ ] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
Here we have not mentioned the size of the array. The compiler is quite intelligent
as it
detects the initialization list which consists of ten 0’s. Therefore, it creates
an array of 10
integers and initializes all the elements with zero.
The index of the arrays starts from the index 0 and is up to one less than the size
of the
array. So if the size of the array is ten, the index will be from 0 to 9. Similarly,
if the size
of the array is 253, the index will be from 0 to 252.
Sample Program 1
Problem Statement:
Page 108
Write a program which reads positive integers from the user and stores these ones
in an
array. User can enter a maximum of 100 numbers. Stop taking input when user enters
1.
Solution:
We have to declare an integer array of size 100 to be used to store the integers.
We used a
loop to get the input from the users. There are two conditions to terminate the
loop i.e.
either user has entered 100 numbers or user entered 1. 'For' and 'while' loops
can execute
zero or more times whereas ‘dowhile’ may execute one or more times. By analyzing
the
problem, the loop will be executed at least once so dowhile loop logically fits
in this
problem. We take an integer
z to get the input from the user and
i as the counter so the
condition will be as ( z !=
1 && i < 100 ). && is used to enforce that both the
conditions are true. If any of the two conditions becomes false, the loop will be
terminated. The loop counter is less than 100 because the index of the array will
be from
0 to 99.
We will read a number from the user and store it at some particular location of
the array
unless user enters 1 or 100 numbers are entered. In the loop, we will use the
if statement
whether the number entered by user is 1 or not. If the number entered is not 1,
then we
will store it in the array. The index of the array will also be incremented in each
repetition. We can assign some value to array element as:
c[ 3 ] = 33;
In an assignment statement, we cannot use expression on the left hand side. Here
c[3] is
used as a variable which represents the 4th element of the array.
The complete code of the program as under:
// This program reads the input from user and store it into an array and stop at
1.
#include <iostream.h>
main( )
{
int c [ 100 ] ;
int i, z;
do
{
int z , i = 0 ;
cout << “Please enter the number (1 to end input) “ << endl;
cin >> z ;
if ( z != 1 )
{
c[ i ] = z ;
Page 109
}
i ++ ;
} while ( z != 1 && i < 100 ) ;
cout << “ The total number of positive integers entered by user is “ << i 1;
}
The above code shows that the assignment statement of the array is inside the
if block.
Here the numbers will be assigned to the array elements when the 'if statement'
evaluates
to true. When the user enters 1, the
if statement will evaluate
it false. So the assignment
statement will not be executed and next
i will be incremented.
The condition in the 'while
loop' will be tested. As the value of
z is 1, the loop will
be terminated.
Now we have to calculate how many positive numbers, the user has entered. In the
end,
we have incremented i
so the actual positive integers entered by the users is
i 1.
The above example is very useful in terms of its practical usage. Suppose we have
to
calculate the ages of students of the class. If we don’t know the exact number of
students
in the class, we can declare an array of integers of larger size and get the ages
from the
user and use 1 to end the input from the user.
A sample out put of the program is as follow.
Please enter the number (1 to end input) 1
2
3
4
5
6
1
The total number of positive integers entered by user is 6
Copying Arrays
Sometimes, we need to copy an array. That means after copying, both the arrays will
contain elements with same values. For being copy able, both arrays need to be of
same
data type and same size. Suppose, we have two arrays a and
b and want to copy array a
into array b. Both arrays are of type int
and of size 10.
int array a[10];
int array b[10];
We know that a value can be assigned to an element of array using the index. So
we can
write assignment statements to copy these arrays as:
b[0] = a[0] ;
b[1] = a[1] ;
b[2] = a[2] ;
Page 110
……
……
……
b[9] = a[9] ;
As the size of array is 10, its index will be from 0 to 9. Using the above technique,
we
can copy one array to another. Now if the array size is 100 or 1000, this method
can be
used. Is there some other way to do things in a better way? We can use the loop
construct
to deal with this easily in the following way.
for (i = 0; i < 10 ; i ++)
{
b[i] = a[i];
}
With the help of loop, it becomes very simple. We are no more worried about the
size of
the array. The same loop will work by just changing the condition. We are assigning
the
corresponding values of array a into array b.
The value of first element of array a is
assigned to the first element of array b and so on.
Example:
Take the sum of squares of 10 different numbers stored in an array.
Here is the code of the program:
// This program calculates the sum of squares of numbers stored in an array.
#include <iostream.h>
main()
{
int a[10];
int sumOfSquares = 0 ;
int i =0;
cout << "Please enter the ten numbers one by one " << endl;
// Getting the input from the user.
for (i = 0 ; i < 10 ; i++ )
{
cin >> a [i];
}
// Calculating the sum of squares.
for ( i = 0 ; i < 10 ; i ++ )
{
Page 111
sumOfSquares = sumOfSquares + a[ i ] * a[ i ] ;
}
cout << “The sum of squares is “ << sumOfSquares << endl;
}
A sample out put of the program is given below.
Please enter the ten numbers one by one
1
2
3
4
5
6
7
8
9
10
The sum of squares is 385
Linear Search
Arrays are used to solve many problems. As we have seen that loops are used along
with
the arrays, so these two constructs are very important. Suppose, we are given a
list of
numbers to find out a specific number out of them. Is the number in the list or
not? Let's
suppose that there are 100 numbers in the list. We take an array of size 100 as
int a [100].
For populating it, , we can request the user to enter the numbers. Either
these numbers
can be stored into the array or we can just populate it with numbers from 0 to 99.
We can
write a simple loop and assign the values as
a[i] = i. This means that
at ith position, the
value is i i.e.
( a[5] = 5 ), at 5th position the value is 5 and so on. Then we can request the
user to enter any number and store this number into an int variable. To search this
number in the array, we write a loop and compare all the elements with the number.
The
loop will be terminated, if we found the number or we have compared all the elements
of
the array, which means that number is not found. We used a flag to show that we
have
found the number or not. If the value of found is zero, the number is not found
while the
value 1 will mean that number has been found. When we find the number, is there
a need
to compare it with other elements of the array? May be not, so when we found the
number, we just jumped out of the loop. In the end, we check the variable
found. If the
value is 1, it means number has been found. Otherwise number stands unfound.
Here is the complete code of the program.
// This program is used to find a number from the array.
#include <iostream.h>
Page 112
main()
{
int z, i ;
int a [ 100 ] ;
// Initializing the array.
for ( i =0 ; i < 100 ; i ++ )
{
a [ i ] = i ;
}
cout << “ Please enter a positive integer “ ;
cin >> z ;
int found = 0 ;
// loop to search the number.
for ( i = 0 ; i < 100 ; i ++ )
{
if ( z == a [ i ] )
{
found = 1 ;
break ;
}
}
if ( found == 1 )
cout << “ We found the integer at index ” << i ;
else
cout << “ The number was not found ” ;
}
The following is an output of the program.
Please enter a positive integer 34
We found the integer at index 34
The loop in the above program may run 100 times or less. The loop will terminate
if the
number is found before the 100th repetition. Therefore, in the linear
search the maximum
limit of the loop execution is the size of the list. If the size of list is 100,
then the loop can
execute a maximum of 100 times.
Using random function (Guessing Game):
We can turn this problem into an interesting game. If we as programmers do not know,
which number is stored in the array? We can make this a guessing game. How can we
do
that? We need some mechanism by which the computer generates some number. In all
the C compilers, a random number generation function is provided. The function is
rand() and is in the standard . To access this function, we need
to include
<stdlib.h> in our program. This function will return a random number. The
number can be between 0 and 32767. We can use this function as:
Page 113
x = rand ( );
The random function generates an integer which is assigned to variable x. Let's
consider
the functioncalling mechanism. The program starts its execution in the main function.
When the control goes to the statement containing a function call, the main program
stops
here and the control goes inside the function called. When the function completes
or
returns some value, the control comes back to the main program.
Here is the complete code of the program using rand().
// This program is used to find a number from the array.
#include <iostream.h>
#include <stdlib.h>
main()
{
int z, i ;
int a [ 100 ] ;
// Initializing the array.
for ( i =0 ; i < 100 ; i ++ )
{
a [i] = rand() ;
}
cout << “ Please enter a positive integer “ ;
cin >> z ;
int found = 0 ;
// loop to search the number.
for ( i = 0 ; i < 100 ; i ++ )
{
if ( z == a [ i ] )
{
found = 1 ;
break ;
}
}
if ( found == 1 )
cout << “ We found the integer at position ” << i ;
else
cout << “ The number was not found ” ;
}
Page 114
The following is an output of the program.
Please enter a positive integer 34
The number was not found
The function rand ( ) returns a value between 0 and 32767. Can we limit the generated
random number in a smaller range? Suppose we have a die with six faces marked with
1,
2, 3, 4, 5 and 6. We want to generate random die number i.e. the number should be
between 1 and 6 inclusive. Here we can use the modulus operator to achieve this.
Modulus operator returns the remainder. What will be the result of the statement?
rand ( ) % 6
When 6 divides any number, the remainder will always be less than 6. Therefore,
the
result will be between 0 and 5 inclusive. We want the number between 1 and 6, therefore
we will add 1.
1 + rand ( ) % 6;
The above statement will give us the desired result. We need to know whether this
is a
fair die or not. A fair die is a die when it is rolled 10 or 100 million of times.
Then on
average, equal number of 1’s, equal number of 2’s, equal number of 3’s etc. will
be
generated. Can we test our die i.e. it is fair or not? That is there are equal numbers
of
chances of 1 or 2 etc. Think about generating a test for our random number generator.
Does it produce a fair die?
The random function is very useful. It can be used to guess the tossing of the coin.
There
can be only two possibilities of tossing a coin. Therefore we can use rand ( ) %
2 which
will give 0 or 1.
The Keyword ‘const’:
To declare an array, we need its data type, name and size. We use simple integer
for the
size like 10 or 100. While using arrays in loops, we use the size a lot. Suppose
if we have
to change the size of the array from 10 to 100, it will have to be changed at all
the places.
Missing a place will lead to unexpected results. There is another way to deal this
situation
i.e. keyword construct. The keyword
const can be used with
any data type and is written
before the data type as:
const int arraySize = 100;
This statement creates an identifier
arraySize and assigns it
the value 100. Now the
arraySize is called integer constant. It is not a variable. We cannot
change its value in the
program. In the array declaration, we can use this as:
int age [arraySize];
Page 115
Now in the loop condition, we can write like this:
for ( i = 0; i < arraySize ; i ++)
If we have to change the size of the array, we only have to change the value of
arraySize
where it is declared. The program will work fine in this case. This is a good programming
practice to use const
for array size.
Tips
• Initialize the array explicitly
• Array index (subscript) starts from 0 and ends one less than the array
size
• To copy an array, the size and data type of both arrays should be same
• Array subscript may be an integer or an integer expression
• Assigning another value to a const is a syntax error



