Arrays Hold Multiple Values

• Array: variable that can store multiple

values of the same type
• Values are stored in adjacent memory
locations
• Declared using [] operator:
int tests[5];
Array - Memory Layout
• The definition:
int tests[5];
allocates the following memory:

first second third fourth fifth

element element element element element
Array Terminology

In the definition int tests[5];

• int is the data type of the array elements
• tests is the name of the array
• 5, in [5], is the size declarator. It shows
the number of elements in the array.
• The size of an array is (number of
elements) * (size of each element)
Array Terminology

• The size of an array is:

– the total number of bytes allocated for it
– (number of elements) * (number of bytes for
each element)
• Examples:
int tests[5] is an array of 20 bytes,
assuming 4 bytes for an int
long double measures[10]is an array of
80 bytes, assuming 8 bytes for a long double
Size Declarators
• Named constants are commonly used as
size declarators.

const int SIZE = 5;

int tests[SIZE];
• This eases program maintenance when
the size of the array needs to be changed.
Accessing Array Elements

• Each element in an array is assigned a

unique subscript.
• Subscripts start at 0

subscripts:
0 1 2 3 4
Accessing Array Elements

• The last element’s subscript is n-1 where n

is the number of elements in the array.

subscripts:
0 1 2 3 4
Accessing Array Elements
• Array elements can be used as regular variables:
tests[0] = 79;
cout << tests[0];
cin >> tests[1];
tests[4] = tests[0] + tests[1];
• Arrays must be accessed via individual
elements:
cout << tests; // not legal
(Program Continues)
Here are the contents of the hours array, with the values
entered by the user in the example output:
Accessing Array Contents

• Can access element with a constant or

literal subscript:
cout << tests[3] << endl;

• Can use integer expression as subscript:

int i = 5;
cout << tests[i] << endl;
Using a Loop to Step Through
an Array
• Example – The following code defines an
array, numbers, and assigns 99 to each
element:

const int ARRAY_SIZE = 5;

int numbers[ARRAY_SIZE];

for (int count = 0; count < ARRAY_SIZE; count++)

numbers[count] = 99;
A Closer Look At the Loop
Default Initialization
• Global array → all elements initialized to 0
by default

• Local array → all elements uninitialized by

default
No Bounds Checking in C++

• When you use a value as an array

subscript, C++ does not check it to make
sure it is a valid subscript.

• In other words, you can use subscripts

that are beyond the bounds of the array.
Code From Program 7-5
• The following code defines a three-element
array, and then writes five values to it!
What the Code Does
No Bounds Checking in C++

• Be careful not to use invalid subscripts.

• Doing so can corrupt other memory
locations, crash program, or lock up
computer, and cause elusive bugs.
Off-By-One Errors
• An off-by-one error happens when you use
array subscripts that are off by one.
• This can happen when you start subscripts
at 1 rather than 0:

// This code has an off-by-one error.

const int SIZE = 100;
int numbers[SIZE];
for (int count = 1; count <= SIZE; count++)
numbers[count] = 0;
 7.4
Array Initialization
Array Initialization
• Arrays can be initialized with an
initialization list:

const int SIZE = 5;

int tests[SIZE] = {79,82,91,77,84};

• The values are stored in the array in the

order in which they appear in the list.
• The initialization list cannot exceed the
array size. 7-21
Code From Program 7-6
Partial Array Initialization

• If array is initialized with fewer initial

values than the size declarator, the
remaining elements will be set to 0:
Implicit Array Sizing
• Can determine array size by the size of
the initialization list:
int quizzes[]={12,17,15,11};

12 17 15 11

• Must use either array size declarator or

initialization list at array definition
Processing Array Contents
• Array elements can be treated as ordinary
variables of the same type as the array

• When using ++, -- operators, don’t

confuse the element with the subscript:
tests[i]++; // add 1 to tests[i]
tests[i++]; // increment i, no
// effect on tests
Array Assignment

To copy one array to another,

• Don’t try to assign one array to the other:
newTests = tests; // Won't work

• Instead, assign element-by-element:

for (i = 0; i < ARRAY_SIZE; i++)
newTests[i] = tests[i];
Printing the Contents of an
Array
• You can display the contents of a
character array by sending its name to
cout:

char fName[] = "Henry";

cout << fName << endl;

But, this ONLY works with character arrays!

Printing the Contents of an
Array
• For other types of arrays, you must print
element-by-element:

for (i = 0; i < ARRAY_SIZE; i++)

cout << tests[i] << endl;
Summing and Averaging
Array Elements
• Use a simple loop to add together array
elements:
int tnum;
double average, sum = 0;
for(tnum = 0; tnum < SIZE; tnum++)
sum += tests[tnum];
• Once summed, can compute average:
average = sum / SIZE;
 Finding the Highest Value in an
Array
int count;
int highest;
highest = numbers[0];
for (count = 1; count < SIZE; count++)
{
if (numbers[count] > highest)
highest = numbers[count];
}

When this code is finished, the highest variable will contains the highest value
in the numbers array.
Finding the Lowest Value in an
Array
int count;
int lowest;
lowest = numbers[0];
for (count = 1; count < SIZE; count++)
{
if (numbers[count] < lowest)
lowest = numbers[count];
}

When this code is finished, the lowest variable will contains the lowest value in
the numbers array.
Using Parallel Arrays
• Parallel arrays: two or more arrays that
contain related data
• A subscript is used to relate arrays:
elements at same subscript are related
• Arrays may be of different types
Parallel Array Example
const int SIZE = 5; // Array size
int id[SIZE]; // student ID
double average[SIZE]; // course average
char grade[SIZE]; // course grade
...
for(int i = 0; i < SIZE; i++)
{
cout << "Student ID: " << id[i]
<< " average: " << average[i]
<< " grade: " << grade[i]
<< endl;
}
(Program Continues)
Program 7-12 (Continued)
The hours and payRate arrays are related through their subscripts:
Arrays as Function Arguments
• To pass an array to a function, just use the array
name:
showScores(tests);
• To define a function that takes an array
parameter, use empty [] for array argument:
void showScores(int []);
// function prototype
void showScores(int tests[])
// function header
Arrays as Function Arguments
• When passing an array to a function, it is common
to pass array size so that function knows how many
elements to process:
showScores(tests, ARRAY_SIZE);
• Array size must also be reflected in prototype,
header:
void showScores(int [], int);
// function prototype
void showScores(int tests[], int size)
// function header

7-38
(Program Continues)
Program 7-14 (Continued)
Modifying Arrays in Functions

• Array names in functions are like

reference variables – changes made to
array in a function are reflected in actual
array in calling function

• Need to exercise caution that array is not

inadvertently changed by a function
Two-Dimensional Arrays
• Can define one array for multiple sets of
data
• Like a table in a spreadsheet
• Use two size declarators in definition:

const int ROWS = 4, COLS = 3;

int exams[ROWS][COLS];

• First declarator is number of rows;

second is number of columns
Two-Dimensional Array
Representation
const int ROWS = 4, COLS = 3; int
exams[ROWS][COLS];
columns
exams[0][0] exams[0][1] exams[0][2]
r exams[1][0] exams[1][1] exams[1][2]
o
w exams[2][0] exams[2][1] exams[2][2]
s
exams[3][0] exams[3][1] exams[3][2]

• Use two subscripts to access element:

exams[2][2] = 86;
7-46
2D Array Initialization

• Two-dimensional arrays are initialized row-by-row:

const int ROWS = 2, COLS = 2;
int exams[ROWS][COLS] = { {84, 78},
{92, 97} };
84 78
92 97

• Can omit inner { }, some initial values in a row –

array elements without initial values will be set to 0
or NULL
Two-Dimensional Array as
Parameter, Argument
• Use array name as argument in function call:
getExams(exams, 2);
• Use empty [] for row, size declarator for column in
prototype, header:
const int COLS = 2;
// Prototype
void getExams(int [][COLS], int);

// Header
void getExams(int exams[][COLS], int rows)
Example – The showArray
Function from Program 7-19
How showArray is Called
Summing All the Elements in a
Two-Dimensional Array
• Given the following definitions:
const int NUM_ROWS = 5; // Number of rows
const int NUM_COLS = 5; // Number of columns
int total = 0; // Accumulator
int numbers[NUM_ROWS][NUM_COLS] =
{{2, 7, 9, 6, 4},
{6, 1, 8, 9, 4},
{4, 3, 7, 2, 9},
{9, 9, 0, 3, 1},
{6, 2, 7, 4, 1}};
 Summing All the Elements in a
Two-Dimensional Array
// Sum the array elements.
for (int row = 0; row < NUM_ROWS; row++)
{
for (int col = 0; col < NUM_COLS; col++)
total += numbers[row][col];
}

// Display the sum.

cout << "The total is " << total << endl;
Summing the Rows of a
Two-Dimensional Array
• Given the following definitions:
const int NUM_STUDENTS = 3;
const int NUM_SCORES = 5;
double total; // Accumulator
double average; // To hold average scores
double scores[NUM_STUDENTS][NUM_SCORES] =
{{88, 97, 79, 86, 94},
{86, 91, 78, 79, 84},
{82, 73, 77, 82, 89}};
Summing the Rows of a
Two-Dimensional Array
// Get each student's average score.
for (int row = 0; row < NUM_STUDENTS; row++)
{
// Set the accumulator.
total = 0;
// Sum a row.
for (int col = 0; col < NUM_SCORES; col++)
total += scores[row][col];
// Get the average
average = total / NUM_SCORES;
// Display the average.
cout << "Score average for student "
<< (row + 1) << " is " << average <<endl;
}
Summing the Columns of a
Two-Dimensional Array
• Given the following definitions:
const int NUM_STUDENTS = 3;
const int NUM_SCORES = 5;
double total; // Accumulator
double average; // To hold average scores
double scores[NUM_STUDENTS][NUM_SCORES] =
{{88, 97, 79, 86, 94},
{86, 91, 78, 79, 84},
{82, 73, 77, 82, 89}};
Summing the Columns of a
Two-Dimensional Array
// Get the class average for each score.
for (int col = 0; col < NUM_SCORES; col++)
{
// Reset the accumulator.
total = 0;
// Sum a column
for (int row = 0; row < NUM_STUDENTS; row++)
total += scores[row][col];
// Get the average
average = total / NUM_STUDENTS;
// Display the class average.
cout << "Class average for test " << (col + 1)
<< " is " << average << endl;
}