Understanding Arrays and Pointers

1. 3 Understanding Arrays and Pointers Object-Oriented Programming Using C++ Second Edition

2. 3 Objectives • In this chapter, you will learn: • How to use the address operator • About arrays • How to store values in an array • How to access and use array values • The value of using a constant to refer to an array’s size

3. 3 Objectives • In this chapter, you will learn: • Techniques to access some of the values in an array • How to use parallel arrays • How to use strings • About special string-handling problems • About pointers • How to use a pointer in place of an array name

4. 3 Using the Address Operator • A variable’s memory address is a fixed location; a variable’s address is a constant • Although you cannot choose a variable’s actual memory address, you can examine it • To do so, you use the address operator (&) • The output is shown in Figure 3-2 • The memory address is of not use to you at this point; you use the address operator merely as a curiosity • The hexadecimal numbering system uses the values 0 through 9, and the letters a through f to represent the decimal values 0 through 15

5. 3 Using the Address Operator

6. 3 Using the Address Operator • In the steps listed on pages 73 and 74 of the textbook, you will experiment with memory addresses in your computer system

7. 3 Understanding Arrays • A list of individual items that all have the same type is called an array • An array holds two or more variables with the same name and type in adjacent memory positions • The variables with the same name are distinguished from one another by their subscripts; the subscript is a number that indicates the position of the particular array element being used • Anytime you need many related variables, consider using an array

8. 3 Understanding Arrays • In C++, you declare an array by using the form type arrayName [size]; where type is any simple type, arrayName is any legal identifier, and size (in the square bracket) represents the number of elements the array contains • An element is a single object in an array • An array name actually represents a memory address • When you declare an array, you tell the compiler to use the array name to indicate the beginning address of a series of elements

9. 3 Understanding Arrays • The subscript used to access an element of an array indicates how much to add to the starting address to locate a value

10. 3 Storing Values in an Array • You most often create an array when you want to store a number of related variable elements • When you declare an array like int array [4];, you set aside enough memory to hold four integers, but you say nothing about the values stored in those four memory locations • The values are unknown—they are whatever was stored in those memory locations before the computer reserved the locations for use by your program • Programmers often say that these memory locations are filled with garbage, or useless values

11. 3 Storing Values in an Array • Just as you can initialize a single variable when you declare it, you can provide values for an array when you declare it • The statement int rent[4] = {250, 375, 460, 600}; provides four values for the array • If you declare an array without a size, but provide initialization values, C++ creates an array with the exact size you need • If you do not provide enough values to fill an array, C++ fills any unassigned array elements with zeros

12. 3 Program that Uses Single and Array Variables F3-6.cpp

13. 3 Accessing and Using Array Values • Once an array is filled with values, you can access and use an individual array value in the same manner you would access and use any single variable of the same type • If you need to access an element in an array, you can use the array name and a constant subscript such as 0 or 1 • Alternately, you can use a variable as a subscript

14. 3 Accessing and Using Array Values • The for loop prints arrayInt[0] through arrayInt[4] because x increases from 0 and remains less than 5 • When the code in Figure 3-9 executes, the user will be prompted 10 times and allowed to enter a floating point value after each prompt • The 10 values will be stored in price[0] through price[9], respectively

15. 3 Accessing and Using Array Values

16. 3 Using a Constant to Refer to an Array’s Size • Often, using a for loop is a convenient way to access all array elements because arrays always have a specific, known size, and for loops execute a specific, known number of times • When you want to access all array elements in sequential order, you can use a subscript that you vary from 0 to 1 less than the number of elements of the array • Figure 3-10 shows a program that declares an array with 12 elements

17. 3 Using a Constant to Control Loops F6-10.cpp

18. 3 Accessing Elements in an Array • When you want to access a single array element, you use a subscript that indicates the position of the value you want to access • When you want to access all of the elements in an array, a for loop usually is convenient • The program in Figure 3-11 declares an array for 30 integer test scores, and single variables that serve as subscripts, a total, and the average • A sentinel or dummy is any value that stops a loop’s execution • You enter the program from Figure 3-11 and modify the program to better understand some of its properties and discover some of its flaws, using the procedures on pages 82 and 83 of the textbook

19. 3 A Program That Averages Up to 30 Test Scores

20. 3 Using Parallel Arrays • When you want to access an array element, you use the appropriate subscript • If each array element’s position has a logical connection to the array value’s purpose, accessing an array value is a straightforward process • Sometimes the numbers you need to access appropriate array values are not small whole numbers

21. 3 A Program That Determines Insurance Premiums

22. 3 Using Parallel Arrays • If you write a program in which you ask the user for a part number so that you can display the price, you cannot use the part number as a subscript to a price array unless you create a price array with at least 456 elements • Creating an array with 456 elements that need to store four prices is cumbersome and inefficient

23. 3 Using Parallel Arrays • A better solution is to create two arrays of just four elements each—one to hold the four part numbers, and one to hold the four prices that correspond to those part numbers • Such corresponding arrays are called parallel arrays

24. 3 Program That Determines Part Prices F3-14.cpp

25. 3 Using Parallel Arrays • Create the program that determines the correct price number for a part, and then improve the program by following the instructions on pages 85 to 87 of the textbook

26. 3 Creating Arrays of Class Objects • Just as you can create arrays of simple types such as int and double, you can create arrays of class objects • The program in Figure 3-16 creates an array of four Automobile objects • To access any individual class object field, you use the object’s individual name, including its subscript, followed by a dot and the field name

27. 3 Creating an Array of Class Objects

28. 3 Output of Program from Figure 3-16

29. 3 Using Strings • In C++, a character variable can hold a single character value, such as ‘A’ or ‘$’ • Single character values are always expressed within single quotation marks • In C++, if you want to express multiple character values, such as a first name or a book title, you use double quotation marks • A C++ value expressed within double quotation marks is commonly called a string

30. 3 Using Strings • You already have used strings with cout statements, as in cout<<“Hello”; • Just as a value such as 14 is a numeric constant, a value such as “Hello” is referred to as a string constant • In C++ an array of characters and a string are declared in the same way • You might create an array of characters if you need to store six one-letter department codes, or five one-letter grades that can be assigned on a test

31. 3 Using Strings • The null character is represented by the combination ‘\0’ (backslash and zero), or by using the constant NULL that is available if you use the statement #include,<iostream.h> at the top of any file you compile

32. 3 Special String Handling Problems • String present some special handling problems • When you use the cin statement with a string, cin stops adding characters to the string when it encounters white space • Often, this means that cin stops when the user presses the Enter key • But cin also stops when the user presses the spacebar or the Tab key

33. 3 A Program That Reads a Name

34. 3 Special String Handling Problems • When the user types Mark Ann in the program in Figure 3-19, the cin statement accepts Mary into the string and leaves Ann waiting in an area called the input buffer • If the program contains a subsequent cin statement, then Ann is accepted and assigned to the string named in the second cin statement

35. 3 Special String Handling Problems

36. 3 Special String Handling Problems • Another string handling problem occurs when you attempt to assign one string to another • To assign the name of the clubPresident to the same name as the clubVicePresident, you must assign each character value in the clubVicePresident name to the corresponding character location in the clubPresident name • A related string-handling problem occurs when you try to compare two strings

37. 3 Special String Handling Problems • If you want to determine whether clubPresident and clubVicePresident have the same name, it might seem natural to write a statement such as: if(clubPresident == clubVicePresident) cout<<“They are the same”<<endl; • You could write instructions to compare two strings by each character of one string to the corresponding character in the other string, such as in the following: if(clubPresident[0]==clubVicePresident[0] && clubPresident[1]==clubVicePresident[1]. . .

38. 3 Using the strcmp() Function

39. 3 Special String Handling Problems • You also can replace this tedious method with the built-in function strcmp( ) • Declaring an array of strings poses a few special problems • To solve them, you must learn to use a two-dimensional array

40. 3 Using Pointers • You also can declare variables that can hold memory addresses • These variables are called pointer variables, or simply pointers • You declare a pointer with a type, just like other variables • The major difference between using a pointer name and the address operator with a variable name is that a pointer is a variable

41. 3 Using a Pointer Instead of an Array Name • Advanced C++ programmers use pointers for many purposes • Sometimes they use a pointer as an alternative to an array name • The program illustrated in Figure 3-25 shows four different ways to access the same seven values • The program declares an integer array with sales figures for seven days for a small business • The program also declares an integer pointer and assigns the address of the first sales figure to that pointer

42. 3 A Program That Uses Array and Pointer Notation F3-25.cpp

43. 3 Output of Program From Figure 3-25

44. 3 Using Pointers to Hold Strings

45. 3 Using a Pointer Instead of an Array Name • Because pointers access computer memory locations, using pointers can be dangerous because you might point to an alter memory locations that you had no intention of altering • A dangling reference is when you delete the value pointed to by one of the pointers, and the other pointer is left without a value

46. 3 Summary • You can examine a variable’s address by using the address operator (&) • An array is a list of individual items that all have the same name and type and are located in adjacent memory positions • You can assign values to array elements individually, using the assignment operator, or at initialization • You can access and use an individual array value the same way you would access and use any single variable of the same type

47. 3 Summary • It is often convenient to declare a constant that is equal to the size of the array • This constant then can be used in every loop that accesses or uses all of the array elements • Programmers often use parallel arrays when they need one array to store values that correspond to values in another list of values • When you create arrays of class objects, you access the object’s public fields by the object’s individual name, including its subscript, followed by a dot and the field name

48. 3 Summary • A C++ multiple-character value expressed within double quotation marks is commonly called a string • Strings present some special handling problems • When you use the cin statement with a string, cin stops adding characters to the string when it encounters whitespace • You can declare pointer variables that hold memory addresses • You can use a pointer as an alternative to using an array name