1. Copyright 2003 Scott/Jones Publishing Alternate Version of Starting Out with C++, Third Edition Chapter 8 Arrays

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

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

4. Chapter 8 slide 4 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];

5. Chapter 8 slide 5 Array - Memory Layout The definition: int tests[5]; allocates the following memory: first element second element third element fourth element fifth element

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

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

8. Chapter 8 slide 8 8.2 Accessing Array Elements Each array element has a subscript, used to access the element. Subscripts start at 0 01234 subscripts:

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

10. Chapter 8 slide 10 Global vs. Local Array Global array  all elements initialized to 0 or NULL Local array  all elements uninitialized by default

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

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

13. Chapter 8 slide 13 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};

14. Chapter 8 slide 14 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}; Initial values used in order; cannot skip over elements to initialize noncontiguous range 7982000

15. Chapter 8 slide 15 Implicit Array Sizing Can determine array size by the size of the initialization list: short quizzes[]={12,17,15,11}; Must use either array size declarator or initialization list at array definition 12171511

16. Chapter 8 slide 16 8.5 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

17. Chapter 8 slide 17 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;

18. Chapter 8 slide 18 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''a''l''e''m' city[0]city[1]city[2]city[3]city[4]

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

20. Chapter 8 slide 20 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;

21. Chapter 8 slide 21 8.7 The typedef Statement Creates an alias for a simple or structured data type Format: typedef ; Example: typedef unsigned int uint; uint tests[5]; // array of unsigned // ints

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

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

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

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

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

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

28. Chapter 8 slide 28 Two-Dimensional Array Representation int exams[4][3]; Use two subscripts to access element: exams[2][2] = 86; exams[0][0]exams[0][1]exams[0][2] 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] columns rowsrows

29. Chapter 8 slide 29 Initialization at Definition Two-dimensional arrays are initialized row-by-row: int exams[2][2] = { {84, 78}, {92, 97} }; Can omit inner { }, some initial values in row – array elements without initial values will be set to 0 or NULL 8478 9297

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

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

32. Chapter 8 slide 32 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 1 st dimension: void getRectSolid(short [][3][5]);

33. Chapter 8 slide 33 8.10 Vectors Defined in the Standard Template Library (Chapter 15) Can hold values of any type: vector scores; Automatically adds space as more is needed – no need to determine size at definition Can use [] to access elements

34. Chapter 8 slide 34 Declaring Vectors Vectors require vector header file Declare a vector: vector scores; Declare a vector with initial size 30: vector scores(30); Declare a vector and initialize all elements to 0: vector scores(20, 0); Declare a vector initialized to size and contents of another vector: vector scores(finals);

35. Chapter 8 slide 35 Growing a Vector’s 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);

36. Chapter 8 slide 36 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())...

37. Chapter 8 slide 37 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];

38. Chapter 8 slide 38 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;

39. Chapter 8 slide 39 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];

40. Chapter 8 slide 40 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();

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

42. Chapter 8 slide 42 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) };

43. Copyright 2003 Scott/Jones Publishing Alternate Version of Starting Out with C++, Third Edition Chapter 8 Arrays

45. A First Book of C++: From Here To There, Third Edition 45 Objectives You should be able to describe: One-Dimensional Arrays Array Initialization Arrays as Arguments Two-Dimensional Arrays Common Programming Errors

46. A First Book of C++: From Here To There, Third Edition 46 One-Dimension Arrays One-Dimension Array(Single-Dimension Array or Vector): a list of related values –All items in list have same data type –All list members stored using single group name Example: a list of grades 98, 87, 92, 79, 85 –All grades are integers and must be declared Can be declared as single unit under a common name (the array name)

47. A First Book of C++: From Here To There, Third Edition 47 One-Dimension Arrays (continued) Array declaration statement provides: –The array(list) name –The data type of array items –The number of items in array Syntax dataType arrayName[numberOfItems] –Common programming practice requires defining number of array items as a constant before declaring the array

48. A First Book of C++: From Here To There, Third Edition 48 One-Dimension Arrays (continued) Examples of array declaration statements: const int NUMELS = 5; // define a constant // for the number of // items int grade[NUMELS]; // declare the array const int ARRAYSIZE = 4; char code[ARRAYSIZE]; const int NUMELS = 6; double prices[NUMELS];

49. A First Book of C++: From Here To There, Third Edition 49 One-Dimension Arrays (continued) Each array allocates sufficient memory to hold the number of data items given in declaration Array element(component): an item of the array Individual array elements stored sequentially –A key feature of arrays that provides a simple mechanism for easily locating single elements

50. A First Book of C++: From Here To There, Third Edition 50 One-Dimension Arrays (continued)

51. A First Book of C++: From Here To There, Third Edition 51 One-Dimension Arrays (continued) Index (subscript value): position of individual element in an array Accessing of array elements: done by giving array name and element’s index –grade[0] refers to first grade stored in grade array Subscripted variables can be used anywhere that scalar variables are valid: –grade[0] = 95.75; –grade[1] = grade[0] - 11.0;

52. A First Book of C++: From Here To There, Third Edition 52 One-Dimension Arrays (continued)

53. A First Book of C++: From Here To There, Third Edition 53 One-Dimension Arrays (continued) Subscripts: do not have to be integers –Any expression that evaluates to an integer may be used as a subscript –Subscript must be within the declared range Examples of valid subscripted variables (assumes i and j are int variables): grade[i] grade[2*i] grade[j-i]

54. A First Book of C++: From Here To There, Third Edition 54 Input and Output of Array Values Individual array elements can be assigned values interactively using a cin stream object cin >> grade[0]; cin >> grade[1] >> grade[2] >> grade[3]; cin >> grade[4] >> prices[6]; Instead, a for loop can be used const int NUMELS = 5; for (int i = 0; i < NUMELS; i++) { cout << "Enter a grade: "; cin >> grade[i]; }

55. A First Book of C++: From Here To There, Third Edition 55 Input and Output of Array Values (continued) Bounds checking: C++ does not check if value of an index is within declared bounds If an out-of-bounds index is used, C++ will not provide notification –Program will attempt to access out-of- bounds element, causing program error or crash –Using symbolic constants helps avoid this problem

56. A First Book of C++: From Here To There, Third Edition 56 Input and Output of Array Values (continued) Using cout to display subscripted variables: –Example 1 cout << prices[5]; –Example 2 cout << "The value of element " << i << " is " << grade[i]; –Example 3 const int NUMELS = 20; for (int k = 5; k < NUMELS; k++) cout << k << " " << amount[k];

57. A First Book of C++: From Here To There, Third Edition 57 Input and Output of Array Values (continued) Program example of array I/O (program 8.1): #include using namespace std; int main() { const int NUMELS = 5; int i, grade[NUMELS]; for (i = 0; i < NUMELS; i++) // Enter the grades { cout << "Enter a grade: "; cin >> grade[i]; } cout << endl; for (i = 0; i < NUMELS; i++) // Print the grades cout << "grade [" << i << "] is " << grade[i] << endl; return 0; }

58. A First Book of C++: From Here To There, Third Edition 58 Input and Output of Array Values (continued) Sample run using Program 8.1: Enter a grade: 85 Enter a grade: 90 Enter a grade: 78 Enter a grade: 75 Enter a grade: 92 grade[0] is 85 grade[1] is 90 grade[2] is 78 grade[3] is 75 grade[4] is 92

59. A First Book of C++: From Here To There, Third Edition 59 Array Initialization Array elements can be initialized within declaration statements –Initializing elements must be included in braces –Example: const int NUMGALS = 20; int gallons[NUMGALS] = {19, 16, 14, 19, 20, 18, // initializing values 12, 10, 22, 15, 18, 17, // may extend across 16, 14, 23, 19, 15, 18, // multiple lines 21, 5};

60. A First Book of C++: From Here To There, Third Edition 60 Array Initialization (continued) Size of array may be omitted when initializing values are included in declaration statement Example: the following are equivalent const int NUMCODES = 6; char code[6] = {'s', 'a', 'm', 'p', 'l', 'e'}; char code[ ] = {'s', 'a', 'm', 'p', 'l', 'e'}; Both declarations set aside 6 character locations for an array named code

61. A First Book of C++: From Here To There, Third Edition 61 Array Initialization (continued) Simplified method for initializing character arrays char code[ ] = “sample”; //no braces or commas This statement uses the string “ sample ” to initialize the code array –The array is comprised of 7 characters –The first 6 characters are the letters: s, a, m, p, l, e –The last character (the escape sequence \0 ) is called the Null character

62. A First Book of C++: From Here To There, Third Edition 62 Array Initialization (continued)

63. A First Book of C++: From Here To There, Third Edition 63 Arrays as Arguments Array elements are passed to a called function in same manner as individual scalar variables –Example: findMax(grades[2], grades[6]); Passing a complete array to a function provides access to the actual array, not a copy –Making copies of large arrays is wasteful of storage

64. A First Book of C++: From Here To There, Third Edition 64 Arrays as Arguments (continued) Examples of function calls that pass arrays int nums[5]; // an array of five integers char keys[256]; // an array of 256 characters double units[500], grades[500];// two arrays of 500 //doubles The following function calls can then be made: findMax(nums); findCharacter(keys); calcTotal(nums, units, grades);

65. A First Book of C++: From Here To There, Third Edition 65 Arrays as Arguments (continued) Suitable receiving side function header lines: int findMax(int vals[5]) char findCharacter(char inKeys[256]) void calcTotal(int arr1[5], double arr2[500], double arr3[500])

66. A First Book of C++: From Here To There, Third Edition 66 Arrays as Arguments (continued) Example of passing arrays as arguments (program 8.4): –Constant MAXELS is declared globally –Prototype for findMax() uses constant MAXELS to declare that findMax() expects an array of five integers as an argument –As shown in Figure 8.7,only one array is created in Program 8.4 In main() the array is known as nums In findMax() it is known as vals

67. A First Book of C++: From Here To There, Third Edition 67 Arrays as Arguments (continued) Example: Program 8.4 #include using namespace std; const int MAXELS = 5; int findMax(int [MAXELS]); // function prototype int main() { int nums[MAXELS] = {2, 18, 1, 27, 16}; cout << "The maximum value is " << findMax(nums) << endl; return 0; } // find the maximum value int findMax(int vals[MAXELS]) { int i, max = vals[0]; for (i = 1; i < MAXELS; i++) if (max < vals[i]) max = vals[i]; return max; }

68. A First Book of C++: From Here To There, Third Edition 68 Arrays as Arguments (continued)

69. A First Book of C++: From Here To There, Third Edition 69 Two-Dimensional Arrays Two-dimensional array (table): consists of both rows and columns of elements Example: two-dimensional array of integers 816 952 3 1527 6 14 25 210 Array declaration: names the array val and reserves storage for it int val[3][4];

70. A First Book of C++: From Here To There, Third Edition 70 Two-Dimensional Arrays (continued) Locating array elements (Figure 8.9) –val[1][3] uniquely identifies element in row 1, column 3 Examples using elements of val array: price = val[2][3]; val[0][0] = 62; newnum = 4 * (val[1][0] - 5); sumRow = val[0][0] + val[0][1] + val[0][2] + val[0][3]; –The last statement adds the elements in row 0 and sum is stored in sumRow

71. A First Book of C++: From Here To There, Third Edition 71 Two-Dimensional Arrays (continued)

72. A First Book of C++: From Here To There, Third Edition 72 Two-Dimensional Arrays (continued) Initialization: can be done within declaration statements (as with single- dimension arrays) Example: int val[3][4] = { {8,16,9,52}, {3,15,27,6}, {14,25,2,10} }; –First set of internal braces contains values for row 0, second set for row 1, and third set for row 2 –Commas in initialization braces are required; inner braces can be omitted

73. A First Book of C++: From Here To There, Third Edition 73 Two-Dimensional Arrays (continued) Processing two-dimensional arrays: nested for loops typically used –Easy to cycle through each array element A pass through outer loop corresponds to a row A pass through inner loop corresponds to a column –Nested for loop in Program 8.7 used to multiply each val element by 10 and display results Output of Program 8.7 Display of multiplied elements 80 160 90 520 30 150 270 60 140 250 20 100

74. A First Book of C++: From Here To There, Third Edition 74 Two-Dimensional Arrays (continued) Prototypes for functions that pass two- dimensional arrays can omit the row size of the array –Example (program 8.8): Display (int nums[ ][4]); –Row size is optional but column size is required The element val[1][3] is located 28 bytes from the start of the array (assuming 4 bytes for an int)

75. A First Book of C++: From Here To There, Third Edition 75 Two-Dimensional Arrays (continued) Determining offset of an array –Computer uses row index, column index and column size to determine offset as shown below and in Figure 8.11

76. A First Book of C++: From Here To There, Third Edition 76 Two-Dimensional Arrays (continued)

77. A First Book of C++: From Here To There, Third Edition 77 Larger-Dimension Arrays Arrays with more than two dimensions allowed in C++ but not commonly used Example: int response[4][10][6] –First element is response[0][0][0] –Last element is response[3][9][5] A three-dimensional array can be viewed as a book of data tables (Figure 8.12) –First subscript (rank) is page number of table –Second subscript is row in table –Third subscript is desired column

78. A First Book of C++: From Here To There, Third Edition 78 Larger-Dimension Arrays (continued)

79. A First Book of C++: From Here To There, Third Edition 79 Common Programming Errors Forgetting to declare an array –Results in a compiler error message equivalent to “invalid indirection” each time a subscripted variable is encountered within a program Using a subscript that references a nonexistent array element –For example, declaring array to be of size 20 and using a subscript value of 25 –Not detected by most C++ compilers and will probably cause a runtime error

80. A First Book of C++: From Here To There, Third Edition 80 Common Programming Errors (continued) Not using a large enough counter value in a for loop counter to cycle through all array elements Forgetting to initialize array elements –Don’t assume compiler does this

81. A First Book of C++: From Here To There, Third Edition 81 Summary Single-dimensional array: a data structure that stores a list of values of same data type –Must specify data type and array size –int num[100]; creates an array of 100 integers Array elements are stored in contiguous locations in memory and referenced using the array name and a subscript –For example, num[22]

82. A First Book of C++: From Here To There, Third Edition 82 Summary (continued) Two-dimensional array is declared by listing both a row and column size with data type and name of array Arrays may be initialized when they are declared –For two-dimensional arrays you list the initial values, in a row-by-row manner, within braces and separating them with commas Arrays are passed to a function by passing name of array as an argument

83. Array [6] Chapter 8 slide 83

84. Array [5]+adding Chapter 8 slide 84

85. Array [7] and max number Chapter 8 slide 85

86. Adding 5 for each Chapter 8 slide 86

87. Multi dimensional array Chapter 8 slide 87

88. Printing matrix Chapter 8 slide 88

89. Adding two matrix Chapter 8 slide 89

90. Chapter 8 slide 90

91. Chapter 8 slide 91

92. Chapter 8 slide 92