Chapter Five

Arrays

5. What is An Array
􀀹A collection of identical data objects, which are stored in consecutive memory locations
under a common heading or a variable name. In other words, an array is a group or a
table of values referred to by the same name. The individual values in array are called
elements. Array elements are also variables.
􀀹Set of values of the same type, which have a single name followed by an index. In C++,
square brackets appear around the index right after the name
􀀹A block of memory representing a collection of many simple data variables stored in a
separate array element, and the computer stores all the elements of an array consecutively in
memory.

5.1. Properties of arrays:

􀀹Arrays in C++ are zero-bounded; that is the index of the first element in the array is 0 and
the last element is N-1, where N is the size of the array.
􀀹It is illegal to refer to an element outside of the array bounds, and your program will crash or
have unexpected results, depending on the compiler.
􀀹Array can only hold values of one type

5.2. Array declaration

􀀹Declaring the name and type of an array and setting the number of elements in an array is
called dimensioning the array. The array must be declared before one uses in like other
variables. In the array declaration one must define:
1. The type of the array (i.e. integer, floating point, char etc.)
2. Name of the array,
3. The total number of memory locations to be allocated or the maximum value of each
subscript. i.e. the number of elements in the array.
􀀹So the general syntax for the declaration is:

DataTypenamearrayname [array size];

􀀹The expression array size, which is the number of elements, must be a constant such as 10 or
a symbolic constant declared before the array declaration, or a constant expression such as
10*sizeof (int), for which the values are known at the time compilation takes place.

Note: array size cannot be a variable whose value is set while the program is running.

􀀹Thus to declare an integer with size of 10 having a name of num is: int num [10];
This means: ten consecutive two byte memory location will be reserved with the
name num.

1
􀀹That means, we can store 10 values of type int without having to declare 10 different
variables each one with a different identifier. Instead of that, using an array we can store 10
different values of the same type, int for example, with a unique identifier.

5.3. Initializing Arrays

􀀹When declaring an array of local scope (within a function), if we do not specify the array
variable will not be initialized, so its content is undetermined until we store some values in
it.
􀀹If we declare a global array (outside any function) its content will be initialized with all its
elements filled with zeros. Thus, if in the global scope we declare:

int day [5];

􀀹every element of day will be set initially to 0:

􀀹But additionally, when we declare an Array, we have the possibility to assign initial values
to each one of its elements using curly brackets { } . For example:

int day [5] = { 16, 2, 77, 40, 12071 };

􀀹The above declaration would have created an array like the following one:

􀀹The number of elements in the array that we initialized within curly brackets { }
must be equal or less than the length in elements that we declared for the array
enclosed within square brackets [ ]. If we have less number of items for the
initialization, the rest will be filled with zero.
􀀹For example, in the example of the day array we have declared that it had 5
elements and in the list of initial values within curly brackets { } we have set 5
different values, one for each element. If we ignore the last initial value (12071) in
the above initialization, 0 will be taken automatically for the last array element.
􀀹Because this can be considered as useless repetition, C++ allows
the possibility of leaving empty the brackets [ ], where the number of
items in the initialization bracket will be counted to set the size of the
array.
int day [] = { 1, 2, 7, 4, 12,9 };
􀀹The compiler will count the number of initialization items which is 6 and set the size of the
array day to 6 (i.e.: day[6])
􀀹You can use the initialization form only when defining the array. You cannot use it
later, and cannot assign one array to another once. I.e.
int arr [] = {16, 2, 77, 40, 12071};
int ar [4];

2
 ar[]={1,2,3,4};//not allowed
arr=ar;//not allowed
􀀹Note: when initializing an array, we can provide fewer values than the array
elements.
E.g. int a [10] = {10, 2, 3}; in this case the compiler sets the remaining elements to zero.

5.4. Accessing and processing array elements

􀀹In any point of the program in which the array is visible we can access individually
anyone of its elements for reading or modifying it as if it was a normal variable. To
access individual elements, index or subscript is used. The format is the following:
name [ index ]
􀀹In c++ the first element has an index of 0 and the last element has an index, which is
one less the size of the array (i.e. arraysize-1). Thus, from the above declaration,
day[0] is the first element and day[4] is the last element.
􀀹Following the previous examples where day had 5 elements and each element is of
type int, the name, which we can use to refer to each element, is the following one:

􀀹For example, to store the value 75 in the third element of the array variable day a
suitable sentence would be: day[2] = 75; //as the third element is found at index 2
􀀹And, for example, to pass the value of the third element of the array variable day to
the variable a , we could write:
a = day[2];
􀀹Therefore, for all the effects, the expression day[2] is like any variable of type int
with the same properties. Thus an array declaration enables us to create a lot of
variables of the same type with a single declaration and we can use an index to
identify individual elements.
􀀹Notice that the third element of day is specified day[2] , since first is day[0] , second
day[1] , and therefore, third is day[2] . By this same reason, its last element is day
[4]. Since if we wrote day [5], we would be acceding to the sixth element of day and
therefore exceeding the size of the array. This might give you either error or
unexpected value depending on the compiler.
􀀹In C++ it is perfectly valid to exceed the valid range of indices for an Array, which
can cause certain detectable problems, since they do not cause compilation errors
but they can cause unexpected results or serious errors during execution. The
reason why this is allowed will be seen ahead when we begin to use pointers.
􀀹At this point it is important to be able to clearly distinguish between the two uses
the square brackets [ ] have for arrays.
oOne is to set the size of arrays during declaration

3
 o The other is to specify indices for a specific array element when accessing the
elements of the array
􀀹We must take care of not confusing these two possible uses of brackets [ ] with
arrays:

Eg: int day[5]; // declaration of a new Array (begins with a type name) day[2] = 75; // access to an
element of the Array.
Other valid operations with arrays in accessing and assigning:
int a=1;
day [0] = a;
day[a] = 5;
b = day [a+2];
day [day[a]] = day [2] + 5;
day [day[a]] = day[2] + 5;
Eg: Arrays example ,display the sum of the numbers in the array

#include <iostream.h>

int day [ ] = {16, 2, 77, 40, 12071};

int n, result=0;

void main () {

for ( n=0 ; n<5 ; n++ ) {

result += day[n]; }

cout<< result;
getch();

5.5. Arrays as parameters

􀀹At some moment we may need to pass an array to a function as a parameter. In C++ it is
not possible to pass by value a complete block of memory as a parameter, even if it is ordered
as an array, to a function, but it is allowed to pass its address, which has almost the same
practical effect and is a much faster and more efficient operation.
􀀹In order to admit arrays as parameters the only thing that we must do when declaring the
function is to specify in the argument the base type for the array that it contains, an
identifier and a pair of void brackets [] . For example, the following function:
void procedure (int arg[])
􀀹admits a parameter of type "Array of int " called arg. In order to pass to this function an
array declared as:

4
 int myarray [40];
􀀹it would be enough with a call like this:
procedure (myarray);
Here you have a complete example:
// arrays as parameters
#include <iostream.h>
#include <conio.h>
void printarray (int arg[], int length) {
for (int n=0; n<length; n++)
cout<<arg[n] << " ";
cout<< "\n";
}
void mult(int arg[], int length) {
for (int n=0; n<length; n++)
arg[n]=2*arg[n];
}
void main () {
int firstarray[] = {5, 10, 15};
int secondarray[] = {2, 4, 6, 8, 10};
printarray (firstarray,3);
printarray (secondarray,5);
mult(firstarray,3);
cout<<”first array after being doubled is\n”;
printarray (firstarray,3);
getch();
}
􀀹As you can see, the first argument (int arg[] ) admits any array of type int , whatever its
length is, for that reason we have included a second parameter that informs the function
the length of each array that we pass to it as the first parameter so that the for loop that
prints out the array can have the information about the size we are interested about. The
function multdoubles the value of each element and the firstarrayis passed to it. After
that the display function is called. The output is modified showing that arrays are
passed by reference.
􀀹To pass an array by value, pass each element to the function

5.6 Multidimensional Arrays

􀀹Multidimensional arrays can be described as arrays of arrays. For example, a bi-
dimensional array can be imagined as a bi-dimensional table of a uniform concrete data
type.

5
􀀹Matrix represents a bi-dimensional array of 3 per 5 values of type int . The way
to declare this array would be: int matrix[3][5];
􀀹For example, the way to reference the second element vertically and fourth horizontally
in an expression would be:

(remember that array indices always begin by 0 )

􀀹Multidimensional arrays are not limited to two indices (two dimensions). They can
contain so many indices as needed, although it is rare to have to represent more than 3
dimensions. Just consider the amount of memory that an array with many indices may
need. For example:
char century [100][365][24][60][60];
􀀹Assigns a char for each second contained in a century, that is more than 3 billion chars !
What would consume about 3000 megabytes of RAM memory if we could declare it?
􀀹Multidimensional arrays are nothing else than an abstraction, since we can simply
obtain the same results with a simple array by putting a factor between its indices:
int matrix [3][5]; is equivalent to
int matrix [15]; (3 * 5 = 15)

􀀹With the only difference that the compiler remembers for us the depth of each
imaginary dimension. Serve as example these two pieces of code, with exactly the same
result, one using bi-dimensional arrays and the other using only simple arrays:
// multidimensional array
#include <iostream.h>
#define WIDTH 5
#define HEIGHT 3
int matrix [HEIGHT][WIDTH];
int n,m;
int main ()
{
for (n=0;n<HEIGHT;n++)
for (m=0;m<WIDTH;m++)
{
matrix [n][m]=(n+1)*(m+1);
}
return 0;
}

6
􀀹None of the programs above produce any output on the screen, but both assign values
to the memory block called matrix in the following way:

􀀹We have used defined constants ( #define ) to simplify possible future

modifications of the program, for example, in case that we decided to enlarge the
array to a height of 4 instead of 3 it would be enough by changing the line: #define
HEIGHT 3
by the following code
#define HEIGHT 4