Module 5 - Array

Arrays
Chapter 12
Overview
• Arrays and their properties

• Creating arrays
• Accessing array elements
• Modifying array elements
• Loops and arrays
Arrays and Their Properties
• Hold several values of the same type

• Based on a slot number (the index number)
• Instant access
• Linear (one after the other)
• Static – once their size is set, it’s set…
Arrays Hold Multiple Values
Regular variable count

int count; 5
Variable count stores one value of type int
Array variable
int days[ 3 ]; Allocates memory for 3 ints
days 2 3 4
1st element 2nd element 3rd element
Array days stores 3 values of type int
4
What arrays look like
• Things to notice
0 1 2 3 4 5 6
myArray
• There are 7 slots, with index numbers 0 – 6

• The name of the array is myArray
• Easy to be off by one
Creating Arrays
<data type> <name> [<size>];
• Notice that we can create an array of any data

type, just by changing the data type!
Examples
• An array of shorts:
short someArray [50];
• An array of floats:
float myArray [25];
• An array of booleans:
bool list [65];
• An array of chars:
char characters [255];
Modifying an Array
• You must specify which slot you are putting information in

• Example:
int myArray [50];
0 1 2 3 4 49
myArray [ 3 ] = 12;
…
• This won’t work: 12
int myArray [50];
myArray = 12;
• Data type on the left of = is an array
• Data type on right of = is an int
Accessing Information
• Copying information out of a particular slot
int clientAge;
clientAge = myArray [ 4 ];
• This copies information from the fifth slot (slot

four) into the variable clientAge
Initializing Arrays
(large arrays)
• For most arrays, you will use a loop to initialize

• Example: Create an array of 5 bytes and fill each
slot with the number 42
byte myList [5];

for (int counter = 0; counter < 5; counter++) {
myList [counter] = 42;
}
Line by Line
byte myList [5];

}
Line by Line
byte myList [5];

}
0 1 2 3 4
0 0 0 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 0
0 0 0 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 0
0 0 0 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 0
0 0 0 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 0
42 0 0 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 1
42 0 0 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 1
42 0 0 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 1
42 0 0 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 1
42 42 0 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 2
42 42 0 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 2
42 42 0 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 2
42 42 0 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 2
42 42 42 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 3
42 42 42 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 3
42 42 42 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 3
42 42 42 0 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 3
42 42 42 42 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 4
42 42 42 42 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 4
42 42 42 42 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 4
42 42 42 42 0
Line by Line
byte myList [5];

} counter
0 1 2 3 4 4
42 42 42 42 42
Line by Line
byte myList [5];

} counter
0 1 2 3 4 5
42 42 42 42 42
Line by Line
false
byte myList [5];
} counter
0 1 2 3 4 5
42 42 42 42 42
Finding the Smallest Element
• If you were given an array of numbers, how

would YOU do it?
• Computers can only compare two at a time
• Go through entire list
• Keep track of smallest so far
• Let’s assume
– We have an array of 5 ints
– The array contains random unknown numbers
– The name of the array is called randomArray
Another Trace
int smallestSoFar;
smallestSoFar = randomArray[0];
if (smallestSoFar > randomArray[counter]) {
smallestSoFar = randomArray[counter];
} // if
} // for
0 1 2 3 4 smallestSoFar
42 17 42 -8 4
Another Trace
int smallestSoFar;
} // if
} // for
42 17 42 -8 4
Another Trace
int smallestSoFar;
} // if
} // for
42 17 42 -8 4 42
Another Trace
int smallestSoFar;
counter
} // if
} // for 1
42 17 42 -8 4 42
Another Trace
int smallestSoFar;
counter
} // if
} // for 1
42 17 42 -8 4 42
Another Trace
int smallestSoFar;
for (int counter = 1; counter < 5; counter++) { Is 42 > 17?
counter
} // if
} // for 1
42 17 42 -8 4 42
Another Trace
int smallestSoFar;
counter
} // if
} // for 1
42 17 42 -8 4 17
Another Trace
int smallestSoFar;
counter
} // if
} // for 1
42 17 42 -8 4 17
Another Trace
int smallestSoFar;
counter
} // if
} // for 2
42 17 42 -8 4 17
Another Trace
int smallestSoFar;
counter
} // if
} // for 2
42 17 42 -8 4 17
Another Trace
int smallestSoFar;
for (int counter = 1; counter < 5; counter++) { Is 17 > 42?
counter
} // if
} // for 2
42 17 42 -8 4 17
Another Trace
int smallestSoFar;
counter
} // if
} // for 2
42 17 42 -8 4 17
Another Trace
int smallestSoFar;
counter
} // if
} // for 3
42 17 42 -8 4 17
Another Trace
int smallestSoFar;
counter
} // if
} // for 3
42 17 42 -8 4 17
Another Trace
int smallestSoFar;
for (int counter = 1; counter < 5; counter++) { Is 17 > -8?
counter
} // if
} // for 3
42 17 42 -8 4 17
Another Trace
int smallestSoFar;
counter
} // if
} // for 3
42 17 42 -8 4 -8
Another Trace
int smallestSoFar;
counter
} // if
} // for 3
42 17 42 -8 4 -8
Another Trace
int smallestSoFar;
counter
} // if
} // for 4
42 17 42 -8 4 -8
Another Trace
int smallestSoFar;
counter
} // if
} // for 4
42 17 42 -8 4 -8
Another Trace
int smallestSoFar;
for (int counter = 1; counter < 5; counter++) { Is -8 > 4?
counter
} // if
} // for 4
42 17 42 -8 4 -8
Another Trace
int smallestSoFar;
counter
} // if
} // for 4
42 17 42 -8 4 -8
Another Trace
int smallestSoFar;
counter
} // if
} // for 5
42 17 42 -8 4 -8
Another Trace
int smallestSoFar;
counter
} // if
} // for 5
42 17 42 -8 4 -8
Another Trace
int smallestSoFar;
counter
} // if
} // for 5
42 17 42 -8 4 -8
Passing Arrays to Functions
#include <iostream.h>
void modifyArray (int inArray[ ], int arraySize) {

// Stuff that changes the array
}
void main ( ) {
int myArray [15];
modifyArray (myArray, 15);
}
The Overall Concept
• Arrays hold values that are all the same type

• Arrays are static in size
• Creating arrays always follows a format
• You can create an array of any type
• To initialize or search arrays, you’ll almost
always use a loop
More on Initializing Arrays
Initialize all three indexed variables of the array “a”

int a[ 3 ] = { 2, 12, 1 }; int a[ 3 ];
is equivalent to: a[ 0 ] = 2;
a[ 1 ] = 12;
a[ 2 ] = 1;
Automatically sized
int b[ ] = { 5, 12, 11 }; is equivalent to: int b[ 3 ] = { 5, 12, 11 };
If fewer values are listed than there are indexed variables, remaining
indexed variables are initialized to zero of the array base type
int c[ 5 ] = { 2, 4, 8 }; Only initializes first 3 elements of 5 element array
2 4 8 0 0 Un-initialized elements set to zero
62
Initializing Strings
If string constant is used, null terminator is automatically included
Element Sized automatically to length of
char short_str [ ] = “abc”; string + 1 for the ‘\0’
data type
Is equivalent to: Is not equivalent to:

char short_str [ 4 ] = “abc”; char short_str [ ] = {‘a’, ‘b’, ‘c’};
‘a’ ‘b’ ‘c’ ‘\0’ ‘a’ ‘b’ ‘c’
Character array also has indexed variables

short_str[ 0 ] short_str[ 1 ] short_str[ 2 ] . . .
int index = 0; Loop ends when element is \0
while ( short_str [ index ] != ‘\0’ )
{
short_str [ index ] = ‘X’; Change value in short_str to
contain all ‘X’ characters
index++;
} 63
More Array Processing
Processing array elements is the same as processing other variables
int score[ 5 ] = { 7, 8, 9, 10, 0 };
++ score [ 2 ]; Increment value in score[ 2 ]

int result = score [ 4 ] * 2; Initializes result to value of
score[ 4 ] times 2
if ( score[ 3 ] < score[ 4 ] ) Is the value in score[ 3 ] less

than the value in score[ 4 ]?
while ( score[ count ] != 0 ) Loop iterates as long as

score[ count ] does not equal 0
64
Parallel Arrays
Using two or more arrays to represent relationships
involving different data types
Number of employees
const int NUMEMPS;
Elements int hours [NUMEMPS]; Stores hours worked by each
are integers employee
Elements float payRate [NUMEMPS]; Stores pay rate for each
are floats . . . employee
for ( int index = 0; index < NUMEMPS; index++ )
{
cout << “Hours employee #” << ( index + 1 );
cin >> hours[ index ];
cout << “Pay rate employee #” << ( index + 1 );
cin >> payRate[ index ]; Same index used to
access both arrays
}
65
Printing Array Contents
Use a loop to display the contents of each array
element
Declare and
int testArr [ 5 ] = { 10, 20, 30, 40, 50 }; initialize array
Doesn’t work!
Displays address of the
cout << testArr << endl; array, not the contents
Works!
for ( int ct = 0; ct < 5; ct++ ) Loop displays value
cout << testArr [ ct ] << endl; of each element
Exception: Displaying the contents of a

char array containing a C-string
char name [ ] = “Ned Nerd”; Displays string, not array address
cout << name << endl;
cout uses \0 when given a char array to determine end of the string
66
Array Elements as Function Arguments
With each loop iteration, the value contained in testArr[ct] is

passed to the function showVal
void showVal ( int num ); Program output:

void main ( ) 5 10 15 20 25
{
int testArr [ 5 ] = { 5, 10, 15, 20, 25 };
for ( int ct = 0; ct < 5; ct++ )
showVal ( testArr [ ct ] ); Array element, type int, as the
argument
}
void showVal ( int num ) Parameter is also type int
{
cout << num << “ “;
}
Array elements can be passed by value or by reference
67
Arrays as Function Arguments
Any changes to parameter nums, effect argument testArr

void showVal ( int nums [ ] );
void main ( ) Program output:
{
int testArr [ 5 ] = { 5, 10, 15, 20, 25 }; 5 10 15 20 25
showVal ( testArr ); Starting address of array is passed to
} function showVal
void showVal ( int nums [ ] )
{
for ( int ct = 0; ct < 5; ct++ )
cout << nums [ ct ] << “ “;
}
0 1 2 3 4
testArr 5 10 15 20 25
nums[0] nums[1] nums[2] nums[3] nums[4] 68

Use two arguments: The address of the array
The size of the array
Modify function showVal to display the contents of an int array of
any size
In int testArr1 [ 2 ] = { 5, 10 };
main: int testArr2 [ 5 ] = { 5, 10, 15, 20, 25 };
int testArr3 [ 7 ] = { 5, 10, 15, 20, 25, 30, 35 };
showVal ( testArr1, 2 );
Function calls Address of array
to showVal showVal ( testArr2, 5 );
Size of array
showVal ( testArr3, 7 );
void showVal ( int nums [ ], int size )

New
{
showVal: for ( int ct = 0; ct < size; ct++ )
cout << nums [ ct ] << “ “;
}
69
Array parameters give direct access to the array argument
void doubleArr ( int nums [ ], int size );
void main ( )
{ Program output:
int testArr [ 5 ] = { 1, 2, 3, 4, 5 };
for ( int ct = 0; ct < 5; ct++ ) 1 2 3 4 5
cout << testArr [ ct ] << “ “; 2 4 6 8 10
doubleArr ( testArr, 5 );
for ( int ct = 0; ct < 5; ct++ )
cout << testArr [ ct ] << “ “;
}
void doubleArr ( int nums [ ], int size )
{
for ( int i = 0; i < size; i++ ) Changes values in
nums [ i ] *= 2; parameter nums and
} argument testArr
70
Two-dimensional Arrays
Two-dimensional array is several identical arrays put
together in the form of a table
Exam scores
column 0 column 1 column 2
row 0 score[0][0] score[0][1] score[0][2]
Students row 1 score[1][0] score[1][1] score[1][2]
row 2 score[2][0] score[2][1] score[2][2]
Number of rows Number of columns
float score [ 3 ] [ 3 ];
Assign value to an element
score [ 1 ] [ 2 ] = 93.2;
Row index
cout << score [ 0 ] [ 2 ];
Column index Display value of an element
71
Two-dimensional Arrays
Nested loops are used to process each element of a
two-dimensional array
float score [ 3 ] [ 3 ];
for ( int std = 0; std < 3; std++ ) Outer loop iterates over rows
{ Inner loop iterates over columns
for ( int exam = 0; exam < 3; exam++ )
{
cout << “Student “ << std + 1 << “ , exam “ << exam + 1 << “: “;
cin >> score [ std ] [ exam ]; Read in an exam score
}
Row Column
cout << endl; index index
Program output:
}
score 0 1 2 Student 1, exam 1: 92.3
Student 1, exam 2: 88.5
0 92.3 88.5 83.6 Student 1, exam 3: 83.6
1 Student 2, exam 1: 79.2
79.2 72.8 ?
Student 2, exam 2: 72.8
2 ? ? ? . . .
72
Two-dimensional Arrays as
Function Arguments
Number of columns is specified in a two-dimensional
array parameter Empty Column index
Number of rows
void showArr ( int Arr [ ] [ 2 ], int rows );
void main ( ) Extra braces that enclose each
{ row’s values are optional
int table [ 3 ] [ 2 ] = { { 8, 5 }, { 7, 9 }, { 6, 3 } };
showArr ( table, 3 );
Row 1 Row 2 Row 3
}
void showArr ( int Arr [ ] [ 2 ], int rows )
{
for ( int r = 0; r < rows; r++ ) Iterates rows Program output:
{
for ( int c = 0; c < 2; c++ ) Iterates columns 8 5
cout << Arr [ r ] [ c ] << “ “; 9 9
cout << endl; 6 3
}
}
73
Arrays Strings
A two-dimensional array of characters can be used
as multiple arrays of strings
char team [ 4 ] [ 9 ] = { “Ned”, “Connie”, “Pat”, “Greg” };
0 N e d \0 Four names,
8 characters long
1 C o n n i e \0
Maximum length of
2 P a t \0 string is 9 – 1
3 G r e g \0 (for null terminator)
Name of array with only a row index is the address of

that row Program
cout << team [ 2 ]; Pat output:
Loop displays all names in the array Ned
for ( int ct = 0; ct < 4; ct++ ) Connie
Pat
cout << team [ ct ] << endl;
Greg
74

Module 5 - Array

Uploaded by

Document Information

Original Description:

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

Module 5 - Array

Uploaded by

Copyright:

Available Formats

Arrays

• Arrays and their properties

• Hold several values of the same type

Regular variable count

Array days stores 3 values of type int

• There are 7 slots, with index numbers 0 – 6

<data type> <name> [<size>];

• Notice that we can create an array of any data

• You must specify which slot you are putting information in

• Copying information out of a particular slot

• This copies information from the fifth slot (slot

• For most arrays, you will use a loop to initialize

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

byte myList [5];

• If you were given an array of numbers, how

void modifyArray (int inArray[ ], int arraySize) {

• Arrays hold values that are all the same type

Initialize all three indexed variables of the array “a”

int c[ 5 ] = { 2, 4, 8 }; Only initializes first 3 elements of 5 element array

2 4 8 0 0 Un-initialized elements set to zero

Is equivalent to: Is not equivalent to:

‘a’ ‘b’ ‘c’ ‘\0’ ‘a’ ‘b’ ‘c’

Character array also has indexed variables

Processing array elements is the same as processing other variables

int score[ 5 ] = { 7, 8, 9, 10, 0 };

++ score [ 2 ]; Increment value in score[ 2 ]

if ( score[ 3 ] < score[ 4 ] ) Is the value in score[ 3 ] less

while ( score[ count ] != 0 ) Loop iterates as long as

Exception: Displaying the contents of a

With each loop iteration, the value contained in testArr[ct] is

void showVal ( int num ); Program output:

Any changes to parameter nums, effect argument testArr

nums[0] nums[1] nums[2] nums[3] nums[4] 68

void showVal ( int nums [ ], int size )

Number of rows Number of columns

Name of array with only a row index is the address of

You might also like