Alternate Version of

Starting Out with C++, Third Edition

Chapter 8 Arrays

Copyright 2003 Scott/Jones Publishing

Topics
8.1 Arrays Hold Multiple Values 8.2 Accessing Array Elements 8.3 Inputting and Displaying Array Contents 8.4 Array Initialization 8.5 Processing Array Contents 8.6 Using Parallel Arrays
Chapter 8 slide 2

Topics
8.7 The typedef Statement
8.8 Arrays as Function Arguments 8.9 Two-Dimensional Arrays 8.10 Vectors 8.13 Arrays of Structures 8.14 Arrays of Class Objects
Chapter 8 slide 3

8.1 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];

Chapter 8 slide 4

Array - Memory Layout

The definition:
int tests[5];

allocates the following memory:

first element

second element

third element

fourth element

fifth element

Chapter 8 slide 5

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)
Chapter 8 slide 6

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
Chapter 8 slide 7

8.2 Accessing Array Elements

Each array element has a subscript, used to access the element. Subscripts start at 0
subscripts: 0 1 2 3 4

Chapter 8 slide 8

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
Chapter 8 slide 9

Global vs. Local Array

Global array all elements initialized to 0 or NULL
Local array all elements uninitialized by default

Chapter 8 slide 10

8.3 Inputting and Displaying Array Contents

Array elements can be used with cin, cout If array represents a C-string or C++ string object, can read in or display using just array name:
char name[10]; // or 'string name;' cin >> name;

cout << name << endl; Arrays of other types: element-by-element

Chapter 8 slide 11

Inputting and Displaying Array Contents

Can access element with constant subscript:
cout << tests[3] << endl;

Can use integer expression as subscript:

for (i = 0; i < 5;i++) cout << tests[i] << endl;

No checks that subscript is in range program may overwrite other memory

Chapter 8 slide 12

8.4 Array Initialization

Can be initialized during program execution with assignment statements:
tests[0] = 79; tests[1] = 82; // etc.

Can be initialized at array definition with an initialization list:

int tests[5] = {79,82,91,77,84};
Chapter 8 slide 13

Partial Array Initialization

If array is initialized at definition with fewer initial values than the size declarator of the array, the remaining elements will be set to 0 or NULL:
int tests[5] = {79, 82};
79 82 0 0 0

Initial values used in order; cannot skip over elements to initialize noncontiguous range
Chapter 8 slide 14

Implicit Array Sizing

Can determine array size by the size of the initialization list:
short quizzes[]={12,17,15,11};
12 17 15 11

Must use either array size declarator or initialization list at array definition
Chapter 8 slide 15

8.5 Processing Array Contents

Array elements can be treated as ordinary variables of the same type as the array When using ++, -- operators, dont confuse the element with the subscript:
tests[i]++; // add 1 to tests[i] tests[i++]; // increment i, no // effect on tests
Chapter 8 slide 16

Sum of Array Elements

Use a simple loop to add together array elements:
int tnum; float average, sum = 0; for(tnum = 0; tnum < 5; tnum++) sum += tests[tnum];

Once summed, can compute average:

average = sum/5;
Chapter 8 slide 17

Strings
Can be processed using array name (entire string at once) or using subscripts(element at a time):
string city; cout << "Enter city name: "; cin >> city;
'S' city[0] 'a' 'l' 'e' 'm' city[1] city[2] city[3] city[4]

Chapter 8 slide 18

8.6 Using Parallel Arrays

Parallel arrays: two or more arrays that contain related data Subscript is used to relate arrays: elements at same subscript are related Arrays may be of different types

Chapter 8 slide 19

Parallel Array Example

string name[5]; // student name float average[5];// course average char grade[5]; // course grade ... for(int i = 0; i < 5; i++) cout << "Student: " << name[i] << " average: " << average[i] << " grade: " << grade[i] << endl;
Chapter 8 slide 20

8.7 The typedef Statement

Creates an alias for a simple or structured data type Format:
typedef <existing type> <new name>;

Example:
typedef unsigned int uint; uint tests[5]; // array of unsigned // ints
Chapter 8 slide 21

Uses of typedef
Used to make code more readable Can be used to create alias for array of a particular type:
typedef int program[8]; // program now names a data type // that is an array of 8 ints program prog1, prog2;// 2 arrays
Chapter 8 slide 22

8.8 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
Chapter 8 slide 23

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, 5);

Array size must also be reflected in prototype, header:

void showScores(int [], int); // function prototype void showScores(int tests[], int size) // function header
Chapter 8 slide 24

Arrays as Function Arguments

Can use typedef to simplify function prototype, heading:
typedef int intArray[]; // typedef void showScores(intArray, int); // function prototype void showScores(intArray tests, int size) // function header
Chapter 8 slide 25

Modifying Arrays in Functions

Array names in functions are similar to 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 inadvertantly changed by a function

Chapter 8 slide 26

8.9 Two-Dimensional Arrays

Can define one array for multiple sets of data Like a table in a spreadsheet Use two size declarators in definition:
int exams[4][3];

First declarator is number of rows; second is number of columns

Chapter 8 slide 27

Two-Dimensional Array Representation

int exams[4][3];
columns exams[0][0] exams[0][1] exams[0][2] r o w s exams[1][0] exams[1][1] exams[1][2] exams[2][0] exams[2][1] exams[2][2] exams[3][0] exams[3][1] exams[3][2]

Use two subscripts to access element:

exams[2][2] = 86;
Chapter 8 slide 28

Initialization at Definition
Two-dimensional arrays are initialized row-by-row:
int exams[2][2] = { {84, 78}, 84 78 {92, 97} };
92 97

Can omit inner { }, some initial values in row array elements without initial values will be set to 0 or NULL
Chapter 8 slide 29

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:
void getExams(int [][2], int); // prototype void getExams(int exams[][2], int rows) // header

Chapter 8 slide 30

Two-Dimensional Array as Parameter, Argument

Can use typedef for simpler notation:
typedef int intExams[][2]; ... void getExams(intExams, int); // prototype void getExams(intExams exams, int rows) // header
Chapter 8 slide 31

Multi-Dimensional Arrays
Can define arrays with any number of dimensions:
short rectSolid(2,3,5); float timeGrid(3,4,3,4);

When used as parameter, specify all but 1st dimension:

void getRectSolid(short [][3][5]);
Chapter 8 slide 32

8.10 Vectors
Defined in the Standard Template Library (Chapter 15) Can hold values of any type:
vector<int> scores;

Automatically adds space as more is needed no need to determine size at definition Can use [] to access elements
Chapter 8 slide 33

Declaring Vectors
Vectors require vector header file Declare a vector:
vector<int> scores;

Declare a vector with initial size 30:

vector<int> scores(30);

Declare a vector and initialize all elements to 0:

vector<int> scores(20, 0);

Declare a vector initialized to size and contents of another vector:

vector<int> scores(finals);
Chapter 8 slide 34

Growing a Vectors Size

Use size member function to determine size of a vector:
howbig = scores.size();

Use push_back member function to add element to a full array or to an array that had no defined size:
scores.push_back(75);
Chapter 8 slide 35

Removing Vector Elements

Use pop_back member function to remove last element from vector:
scores.pop_back();

To remove all contents of vector, use clear member function:

scores.clear();

To determine if vector is empty, use empty member function:

while (!scores.empty()) ...
Chapter 8 slide 36

8.13 Arrays of Structures

Structures can be used as array elements:
struct Student {

int studentID; string name; short yearInSchool; float gpa;

}; Student class[30];
Chapter 8 slide 37

Arrays of Structures
Use array subscript to access a specific structure in the array Then, use dot operator to access members of structure:
cin >> class[25].studentID; cout << class[i].name << "has GPA " << class[i].gpa << endl;
Chapter 8 slide 38

8.14 Arrays of Class Objects

Classes can also be used as array elements:
class square { private: int side; public: void setSide(int s) { side = s; } int getSide() { return side; } }; square shapes[10];
Chapter 8 slide 39

Arrays of Class Objects

Use subscript to access a specific object in an object the array Use dot operator to access member functions of that object:
shapes[4].setSide(12); for (i=0; i<10; i++) cout << shapes[i].getSide();
Chapter 8 slide 40

Initialize Array of Objects

Can use default constructor to perform same initialization for all objects Can use initialization list to supply specific initial values of objects: Square shapes[5] = {1,2,3,4,5}; Default constructor used for remaining objects if initialization list is too short Must call constructor in initialization list if it takes > 1 argument
Chapter 8 slide 41

Initialize Array of Objects

If class has constructor that takes > 1 argument, then initialization list must include a call to the constructor:
Rectangle spaces[3] = { Rectangle(2,5), Rectangle(1,3), Rectangle(7,7) };

Chapter 8 slide 42

Alternate Version of

Starting Out with C++, Third Edition

Chapter 8 Arrays

Copyright 2003 Scott/Jones Publishing