Chapter 6 Arrays: Lecturer: Mrs Rohani Hassan

Chapter 6 Arrays
Lecturer: Mrs Rohani Hassan
Liang, Introduction to C++ Programming, (c) 2007 Pearson Education, Inc. All rights reserved.
013225445X
1
Objectives
 To describe why an array is necessary in programming (§6.1).
 To learn how to declare an array (§6.2.1).
 To access array elements using indexed variables (§6.2.2).
 To initialize the values in an array (§6.2.3).
 To develop and invoke functions with array arguments (§§6.3-6.4).
 To declare and create two-dimensional arrays (§6.7).
 (Optional) To declare and create multidimensional arrays (§6.8).
013225445X
2
Introducing Arrays
Array is a data structure that represents a collection of the
same types of data.
double myList [10];
myList[0] 5.6
myList[1] 4.5
myList[2] 3.3
myList[3] 13.2
myList[4] 4.0
Array element at
myList[5] 34.33 Element value
index 5
myList[6] 34.0
myList[7] 45.45
myList[8] 99.993
myList[9] 111.23
013225445X
3
Declaring Array Variables
datatype arrayRefVar[arraySize];
Example:
double myList[10];
C++ requires that the array size used to declare an array must be a
constant expression. For example, the following code is illegal:
int size = 4;
double myList[size]; // Wrong
But it would be OK, if size is a constant as follow:
const int size = 4;
double myList[size]; // Correct
013225445X
4
Arbitrary Initial Values
When an array is created, its elements are assigned
with arbitrary values.
013225445X
5
Indexed Variables
The array elements are accessed through the index. Array
indices are 0-based; that is, they start from 0 to arraySize-1.
In the example in Figure 6.1, myList holds ten double
values and the indices are from 0 to 9.
Each element in the array is represented using the

following syntax, known as an indexed variable:
arrayName[index];
For example, myList[9] represents the last element in the

array myList.
013225445X
6
Using Indexed Variables
After an array is created, an indexed variable can
be used in the same way as a regular variable.
For example, the following code adds the value
in myList[0] and myList[1] to myList[2].
myList[2] = myList[0] + myList[1];
013225445X
7
No Bound Checking
C++ does not check array’s boundary. So,
accessing array elements using subscripts beyond
the boundary (e.g., myList[-1] and myList[11])
does not does cause syntax errors, but the operating
system might report a memory access violation.
013225445X
8
Array Initializers
Declaring, creating, initializing in one step:
dataType arrayName[arraySize] = {value0, value1,
..., valuek};
double myList[4] = {1.9, 2.9, 3.4, 3.5};
013225445X
9
Declaring, creating, initializing
Using the Shorthand Notation
double myList[4] = {1.9, 2.9, 3.4, 3.5};
This shorthand notation is equivalent to the
following statements:
double myList[4];
myList[0] = 1.9;
myList[1] = 2.9;
myList[2] = 3.4;
myList[3] = 3.5;
013225445X
10
CAUTION
Using the shorthand notation, you have to declare,
create, and initialize the array all in one statement.
Splitting it would cause a syntax error. For
example, the following is wrong:
double myList[4];
myList = {1.9, 2.9, 3.4, 3.5};
013225445X
11
Implicit Size
C++ allows you to omit the array size when
declaring and creating an array using an initilizer.
For example, the following declaration is fine:
double myList[] = {1.9, 2.9, 3.4, 3.5};
C++ automatically figures out how many elements

are in the array.
013225445X
12
Partial Initialization
C++ allows you to initialize a part of the array. For
example, the following statement assigns values
1.9, 2.9 to the first two elements of the array. The
other two elements will be set to zero. Note that if
an array is declared, but not initialized, all its
elements will contain “garbage”, like all other local
variables.
double myList[4] = {1.9, 2.9};
013225445X
13
Initializing Character Arrays
char city[] = {'D', 'a', 'l', 'l', 'a', 's'};
char city[] = "Dallas";

This statement is equivalent to the preceding statement,
except that C++ adds the character '\0', called the null
terminator, to indicate the end of the string, as shown in
Figure 6.2. Recall that a character that begins with the back
slash symbol (\) is an escape character.
'D' 'a' 'l' 'l' 'a' 's' '\0'

city[0] city[1] city[2] city[3] city[4] city[5] city[6]
013225445X
14
Initializing arrays with random
values
The following loop initializes the array myList with random
values between 0 and 99:
for (int i = 0; i < ARRAY_SIZE; i++)

{
myList[i] = rand() % 100;
}
013225445X
15
Printing arrays
To print an array, you have to print each element in the array
using a loop like the following:

{
cout << myList[i] << " ";
}
013225445X
16
Printing Character Array
For a character array, it can be printed using one print
statement. For example, the following code displays
Dallas:
char city[] = "Dallas";

cout << city;
013225445X
17
Copying Arrays
Can you copy array using a syntax like this?
list = myList;
This is not allowed in C++. You have to copy individual

elements from one array to the other as follows:

{
list[i] = myList[i];
}
013225445X
18
Summing All Elements
Use a variable named total to store the sum. Initially total
is 0. Add each element in the array to total using a loop
like this:
double total = 0;
{
total += myList[i];
}
013225445X
19
Finding the Largest Element
Use a variable named max to store the largest element.
Initially max is myList[0]. To find the largest element in
the array myList, compare each element in myList with
max, update max if the element is greater than max.
double max = myList[0];

{
if (myList[i] > max) max = myList[i];
}
013225445X
20
Finding the smallest index of the
largest element
double max = myList[0];
int indexOfMax = 0;
{
if (myList[i] > max)
{
max = myList[i];
indexOfMax = i;
}
}
013225445X
21
animation
Trace Program with Arrays
Declare array variable values, create an
array, and assign its reference to values
int main()
{ After the array is created
int values[5]; 0 0
for (int i = 1; i < 5; i++) 1 0
{ 2 0
values[i] = values[i] + values[i-1]; 3 0
} 4 0
values[0] = values[1] + values[4];

}
013225445X
22
animation
i becomes 1
int main()
{ After the array is created
int values[5];
for (int i = 1; i < 5; i++) 0 0
{ 1 0
0
values[i] = values[i] + values[i-1]; 2
3 0
} 4 0
}
013225445X
23
animation
i (=1) is less than 5
int main()
{
After the array is created
int values[5];
for (int i = 1; i < 5; i++) 0 0
{ 1 0
} 3 0
4 0
}
013225445X
24
animation
After this line is executed, value[1] is 1
int main()
{ After the first iteration
int values[5]; 0 0
for (int i = 1; i < 5; i++) 1 1
{ 2 0
} 4 0

}
013225445X
25
animation

After i++, i becomes 2
int main()
{
int values[5]; After the first iteration
for (int i = 1; i < 5; i++) 0 0
{ 1
2
1
values[i] = values[i] + 3 0
values[i-1]; 4 0
}
values[0] = values[1] +
values[4];
}
013225445X
26
animation
i (= 2) is less than 5
int main()
{
int values[5];
for (int i = 1; i < 5; i++) After the first iteration
{ 0 0
values[i] = values[i] + 1 1
values[i-1]; 2 0
3 0
} 4 0
values[0] = values[1] +
values[4];
}
013225445X
27
animation
After this line is executed,
values[2] is 3 (2 + 1)
int main()
{ After the second iteration
int values[5]; 0 0
for (int i = 1; i < 5; i++) 1 1
{ 2 3
} 4 0

}
013225445X
28
animation
After this, i becomes 3.
int main()
int values[5]; 0 0
for (int i = 1; i < 5; i++) 1 1
{ 2 3
} 4 0

}
013225445X
29
animation
i (=3) is still less than 5.
int main()
int values[5]; 0 0
for (int i = 1; i < 5; i++) 1 1
{ 2 3
} 4 0

}
013225445X
30
animation
After this line, values[3] becomes 6 (3 + 3)
int main()
{ After the third iteration
int values[5]; 0 0
for (int i = 1; i < 5; i++) 1 1
{ 2 3
} 4 0

}
013225445X
31
animation
After this, i becomes 4
int main()
int values[5]; 0 0
for (int i = 1; i < 5; i++) 1 1
{ 2 3
} 4 0

}
013225445X
32
animation
i (=4) is still less than 5
int main()
int values[5]; 0 0
for (int i = 1; i < 5; i++) 1 1
{ 2 3
} 4 0

}
013225445X
33
animation
After this, values[4] becomes 10 (4 + 6)
int main()
{ After the fourth iteration
int values[5]; 0 0
for (int i = 1; i < 5; i++) 1 1
{ 2 3
} 4 10

}
013225445X
34
animation
After i++, i becomes 5
int main()
{
int values[5];
for (int i = 1; i < 5; i++)
{ After the fourth iteration
values[i] = values[i] + values[i-1];
} 0 0
values[0] = values[1] + values[4]; 1 1
} 2 3
3 6
4 10
013225445X
35
animation

i ( =5) < 5 is false. Exit the loop
int main()
{
int values[5];
for (int i = 1; i < 5; i++) After the fourth iteration
{
values[i] = values[i] + values[i-1]; 0
1
0
1
} 2 3
} 4 10
013225445X
36
animation
After this line, values[0] is 11 (1 + 10)
int main()
{
int values[5];
for (int i = 1; i < 5; i++) 0 11
{ 1 1
} 3 6
013225445X
37
Example: Testing Arrays
 Objective: The program receives 6 numbers from
the user, finds the largest number and counts the
occurrence of the largest number entered.
Suppose you entered 3, 5, 2, 5, 5, and 5, the
largest number is 5 and its occurrence count is 4.
TestArray Run
013225445X
38
Example: Assigning Grades
 Objective: read student scores (int), get the best
score, and then assign grades based on the
following scheme:
– Grade is A if score is >= best–10;
– Grade is B if score is >= best–20;
AssignGrade
– Grade is C if score is >= best–30;
– Grade is D if score is >= best–40; Run
– Grade is F otherwise.
013225445X
39
Passing Arrays to Functions
Just as you can pass single values to a function,
you can also pass an entire array to a function.
Listing 6.3 gives an example to demonstrate how
to declare and invoke this type of functions.
PassArrayDemo
Run
013225445X
40
Passing Size along with Array
Normally when you pass an array to a function, you
should also pass its size in another argument. So the
function knows how many elements are in the array.
Otherwise, you will have to hard code this into the
function or declare it in a global variable. Neither is
flexible or robust.
013225445X
41
Pass-by-Reference
Passing an array variable means that the starting
address of the array is passed to the formal
parameter. The parameter inside the function
references to the same array that is passed to the
function. No new arrays are created. This is pass-
by-reference.
PassByReferenceDemo
Run
013225445X
42
const Parameters
Passing arrays by reference makes sense for performance
reasons. If an array is passed by value, all its elements must
be copied into a new array. For large arrays, it could take
some time and additional memory space. However, passing
arrays by reference could lead to errors if your function
changes the array accidentally. To prevent it from
happening, you can put the const keyword before the array
parameter to tell the compiler that the array cannot be
changed. The compiler will report errors if the code in the
function attempts to modify the array.
ConstArrayDemo Compile error

013225445X
43
Modifying Arrays in Functions
Can you return an array from a function using a similar
syntax? For example, you may attempt to declare a
function that returns a new array that is a reversal of an
array as follows:
// Return the reversal of list
int[] reverse(const int list[], int size)
This is not allowed in C++.
013225445X
44
Modifying Arrays in Functions, cont.
However, you can circumvent this restriction by passing
two array arguments in the function, as follows:
// newList is the reversal of list
void reverse(const int list[], list newList[], int size)
list
newList
ReverseArray Run
013225445X
45
animation
Trace the reverse Function

int list1[] = {1, 2, 3, 4, 5, 6};
reverse(list1, list2);
void reverse(const int list[], int newList[], int size)

{
for (int i = 0, j = size - 1; i < size; i++, j--)
{
newList[j] = list[i];
}
}
list 1 2 3 4 5 6
newList 0 0 0 0 0 0
013225445X
46
animation
Trace the reverse Method, cont.

int list1[] = {1, 2, 3, 4, 5, 6};
i = 0 and j = 5

{
{
}
}
list 1 2 3 4 5 6
newList 0 0 0 0 0 0
013225445X
47
animation

int list1[] = {1, 2, 3, 4, 5, 6};
reverse(list1, list2); i (= 0) is less than 6

{
{
}
}
list 1 2 3 4 5 6
newList 0 0 0 0 0 0
013225445X
48
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
newList[j] = list[i]; i = 0 and j = 5
} Assign list[0] to result[5]
}
list 1 2 3 4 5 6
newList 0 0 0 0 0 1
013225445X
49
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
newList[j] = list[i]; After this, i becomes 1
} and j becomes 4
}
list 1 2 3 4 5 6
newList 0 0 0 0 0 1
013225445X
50
animation

int list1[] = {1, 2, 3, 4, 5, 6};
i (=1) is less than 6

{
{
}
}
list 1 2 3 4 5 6
newList 0 0 0 0 0 1
013225445X
51
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
} i = 1 and j = 4
Assign list[1] to result[4]
}
list 1 2 3 4 5 6
newList 0 0 0 0 2 1
013225445X
52
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
} After this, i becomes 2
and j becomes 3
}
list 1 2 3 4 5 6
newList 0 0 0 0 2 1
013225445X
53
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
newList[j] = list[i]; i (=2) is still less than 6
}
}
list 1 2 3 4 5 6
newList 0 0 0 0 2 1
013225445X
54
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
} i = 2 and j = 3
Assign list[i] to result[j]
}
list 1 2 3 4 5 6
newList 0 0 0 3 2 1
013225445X
55
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
newList[j] = list[i]; After this, i becomes 3
} and j becomes 2
list 1 2 3 4 5 6
newList 0 0 0 3 2 1
013225445X
56
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
} i (=3) is still less than 6
}
list 1 2 3 4 5 6
newList 0 0 0 3 2 1
013225445X
57
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
} i = 3 and j = 2
}
list 1 2 3 4 5 6
newList 0 0 4 3 2 1
013225445X
58
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
} and j becomes 1
list 1 2 3 4 5 6
newList 0 0 4 3 2 1
013225445X
59
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
}
list 1 2 3 4 5 6
newList 0 0 4 3 2 1
013225445X
60
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
i = 4 and j = 1
newList[j] = list[i]; Assign list[i] to result[j]
}
}
list 1 2 3 4 5 6
newList 0 5 4 3 2 1
013225445X
61
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
and j becomes 0
}
list 1 2 3 4 5 6
newList 0 5 4 3 2 1
013225445X
62
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
}
list 1 2 3 4 5 6
newList 0 5 4 3 2 1
013225445X
63
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
} i = 5 and j = 0
}
list 1 2 3 4 5 6
newList 6 5 4 3 2 1
013225445X
64
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
After this, i becomes 6
} and j becomes -1
}
list 1 2 3 4 5 6
newList 6 5 4 3 2 1
013225445X
65
animation

int list1[] = {1, 2, 3, 4, 5, 6};

{
{
newList[j] = list[i]; i (=6) < 6 is false. So exit
} the loop.
list 1 2 3 4 5 6
newList 6 5 4 3 2 1
013225445X
66
Two-dimensional Arrays
// Declare array ref var
dataType arrayName[rowSize][columnSize];
int matrix[5][5];
013225445X
67
Two-dimensional Array Illustration
[0] [1] [2] [3] [4] [0] [1] [2] [3] [4] [0] [1] [2] [3]
[0] [0] [0] 1 2 3
[1] [1] 4 5 6
[1]
[2] [2] 7 [2] 7 8 9
[3] [3] [3] 10 11 12
[4] [4] int array[][] = {

{1, 2, 3},
int matrix[5][5]; {4, 5, 6},
matrix[2][1] = 7; {7, 8, 9},
{10, 11, 12}
};
013225445X
68
Declaring, Creating, and Initializing Using
Shorthand Notations
You can also use an array initializer to declare, create and
initialize a two-dimensional array. For example,
int array[4][3] = { int array[4][3];

{1, 2, 3}, Equivalent array[0][0] = 1; array[0][1] = 2; array[0][2] = 3;
{4, 5, 6}, array[1][0] = 4; array[1][1] = 5; array[1][2] = 6;
{7, 8, 9}, array[2][0] = 7; array[2][1] = 8; array[2][2] = 9;
{10, 11, 12} array[3][0] = 10; array[3][1] = 11; array[3][2] = 12;
};
(b)
(a)
013225445X
69
Initializing Arrays with Random Values
The following loop initializes the array with random
values between 0 and 99:
for (int row = 0; row < rowSize; row++)

{
for (int column = 0; column < columnSize; column++)
{
matrix[row][column] = rand() % 100;
}
}
013225445X
70
Printing Arrays
To print a two-dimensional array, you have to print each
element in the array using a loop like the following:

{
{
cout << matrix[row][column] << " ";
}
cout << endl;
}
013225445X
71
Summing All Elements
To print a two-dimensional array, you have to print each
element in the array using a loop like the following:

{
{
cout << matrix[row][column] << " ";
}
cout << endl;
}
013225445X
72
Summing Elements by Column
For each column, use a variable named total to store its
sum. Add each element in the column to total using a
loop like this:

{
int total = 0;
total += matrix[row][column];
cout << "Sum for column " << column << " is " << total
<< endl;
}
013225445X
73
Which row has the largest sum?
Use variables maxRow and indexOfMaxRow to
track the largest sum and index of the row. For
each row, compute its sum and update maxRow
and indexOfMaxRow if the new sum is greater.
013225445X
74
Passing Two-Dimensional Arrays
to Functions
You can pass a two-dimensional array to a
function; however, C++ requires that the
column size to be specified in the function
declaration. Listing 6.11 gives an example with
a function that returns the sum of all the
elements in a matrix.
PassTwoDimensionalArray Run
013225445X
75
Example: Grading Multiple-
Choice Test
 Objective: write a
Students’ Answers to the Questions:
0 1 2 3 4 5 6 7 8 9
program that grades
Student 0 A B A C C D E E A D multiple-choice test.
Student 1 D B A B C A E E A D
Student 2 E D D A C B E E A D
Student 3 C B A E D C E E A D Key to the Questions:
Student 4 A B D C C D E E A D 0 1 2 3 4 5 6 7 8 9
Student 5 B B E C C D E E A D
Student 6 B B A C C D E E A D Key D B D C C D A E A D
Student 7 E B E C C D E E A D
GradeExam Run
013225445X
76
Example: Computing Taxes
Using Arrays
Listing 5.9, ComputeTaxWithFunction.cpp, simplified
Listing 3.5, ComputeTaxWithSelectionStatement.cpp.
Listing 5.9 can be further improved using arrays. For
each filing status, there are six tax rates. Each rate is
applied to a certain amount of taxable income.
ComputeTax Run
013225445X
77
Refine the table
10% 6000 12000 6000 10000

15% 27950 46700 23350 37450
27% 67700 112850 56425 96745
30% 141250 171950 85975 156600
35% 307050 307050 153525 307050
38.6%
013225445X
78
Reorganize the table
6000 12000 6000 10000
27950 46700 23350 37450
67700 112850 56425 96745
141250 171950 85975 156600
307050 307050 153525 307050
Rotate
6000 27950 67700 141250 307050 Single filer

12000 46700 112850 171950 307050 Married jointly
6000 23350 56425 85975 153525 Married separately
10000 37450 96745 156600 307050 Head of household
013225445X
79
Declare Two Arrays
6000 27950 67700 141250 307050 Single filer
12000 46700 112850 171950 307050 Married jointly
6000 23350 56425 85975 153525 Married separately
10000 37450 96745 156600 307050 Head of household
10% int[][] brackets = {

{6000, 27950, 67700, 141250, 307050}, // Single filer
15%
{12000, 46700, 112850, 171950, 307050}, // Married jointly
27% {6000, 23350, 56425, 85975, 153525}, // Married separately
30% {10000, 37450, 96700, 156600, 307050} // Head of
household
35% };
38.6%
double[] rates = {0.10, 0.15, 0.27, 0.30, 0.35, 0.386};
013225445X
80
Multidimensional Arrays
In the preceding section, you used a two-dimensional array
to represent a matrix or a table. Occasionally, you will
need to represent n-dimensional data structures. In C++,
you can create n-dimensional arrays for any integer n.
The way to declare two-dimensional array can be

generalized to declare n-dimensional array for n >= 3. For
example, the following syntax declares a three-
dimensional array scores.
double scores[10][5][2];
013225445X
81
Example: Calculating Total Scores
 Objective: write a program that calculates the total score for

students in a class. Suppose the scores are stored in a three-
dimensional array named scores. The first index in scores refers to
a student, the second refers to an exam, and the third refers to the
part of the exam. Suppose there are 7 students, 5 exams, and each
exam has two parts--the multiple-choice part and the programming
part. So, scores[i][j][0] represents the score on the multiple-choice
part for the i’s student on the j’s exam. Your program displays the
total score for each student.
TotalScore Run
013225445X
82
Example: Guessing Birth Date
Listing 3.2, GuessBirthDate.cpp, gives a
program that guesses a birth date. The
program can be simplified by storing the
numbers in five sets in a three dimensional
array and prompts the user for the answers
using a loop, as shown in Listing 6.15:
GuessBirthDateUsingArray Run
013225445X
83

Chapter 6 Arrays: Lecturer: Mrs Rohani Hassan

Uploaded by

Copyright:

Available Formats

Chapter 6 Arrays: Lecturer: Mrs Rohani Hassan

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Chapter 6 Arrays: Lecturer: Mrs Rohani Hassan

Uploaded by

Copyright:

Available Formats

Chapter 6 Arrays

Lecturer: Mrs Rohani Hassan

Each element in the array is represented using the

For example, myList[9] represents the last element in the

myList[2] = myList[0] + myList[1];

double myList[4] = {1.9, 2.9, 3.4, 3.5};

double myList[] = {1.9, 2.9, 3.4, 3.5};

C++ automatically figures out how many elements

double myList[4] = {1.9, 2.9};

char city[] = "Dallas";

'D' 'a' 'l' 'l' 'a' 's' '\0'

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

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

char city[] = "Dallas";

This is not allowed in C++. You have to copy individual

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

double max = myList[0];

values[i] = values[i] + values[i-1]; 3 0

values[0] = values[1] + values[4];

values[i] = values[i] + values[i-1]; 2 0

values[i] = values[i] + values[i-1]; 3 0

values[0] = values[1] + values[4];

Trace Program with Arrays

for (int i = 1; i < 5; i++) 0 0

values[i] = values[i] + values[i-1]; 3 0

values[0] = values[1] + values[4];

values[i] = values[i] + values[i-1]; 3 0

values[0] = values[1] + values[4];

values[i] = values[i] + values[i-1]; 3 0

values[0] = values[1] + values[4];

values[i] = values[i] + values[i-1]; 3 6

values[0] = values[1] + values[4];

values[i] = values[i] + values[i-1]; 3 6

values[0] = values[1] + values[4];

values[i] = values[i] + values[i-1]; 3 6

values[0] = values[1] + values[4];

values[i] = values[i] + values[i-1]; 3 6

values[0] = values[1] + values[4];

Trace Program with Arrays

values[0] = values[1] + values[4]; 3 6

values[i] = values[i] + values[i-1]; 2 3

values[0] = values[1] + values[4]; 4 10

ConstArrayDemo Compile error

Trace the reverse Function

void reverse(const int list[], int newList[], int size)

Trace the reverse Method, cont.

void reverse(const int list[], int newList[], int size)

Trace the reverse Method, cont.

void reverse(const int list[], int newList[], int size)

Trace the reverse Method, cont.

void reverse(const int list[], int newList[], int size)

Trace the reverse Method, cont.

void reverse(const int list[], int newList[], int size)

Trace the reverse Method, cont.

i (=1) is less than 6

Trace the reverse Method, cont.

void reverse(const int list[], int newList[], int size)

Trace the reverse Method, cont.

void reverse(const int list[], int newList[], int size)