LOGO ObjectOriented Programming Using C Understanding Arrays Strings

LOGO Object-Oriented Programming Using C++ Understanding Arrays, Strings, and Pointers

Objectives v. Learn about memory addresses v. Learn about arrays v. Store values in an array v. Access and use array values § Avoid common errors with arrays v. Learn techniques to access part of an array 2

Objectives (continued) v. Use parallel arrays v. Learn how to use strings v. Discover special string-handling problems v. Learn about pointers v. Use a pointer in place of an array name 3

Understanding Memory Addresses v. Each location where a piece of data can be stored is identified by a memory address v. When you declare a variable with a statement such as int my. Age; § The computer chooses an available memory location § Associates the name my. Age with the memory address of that location 4

Understanding Memory Addresses (continued) Address operator Address appears as a hexadecimal number 5

Understanding Arrays v. Array: list of items that all have the same type v. Subscript: number that indicates the position of the particular array element being used v. Element: single object in an array vdouble money. Collected[5]; 6

Understanding Arrays (continued) int some. Numbers[7]; cout<<some. Numbers produces the same output as cout<<&some. Numbers[0] v. If you access some. Numbers[7], you may get a warning or a garbage value 7

Storing Values in an Array int rent[4]; rent[0] = 250; rent[1] = 375; rent[2] = 460; rent[3] = 600; int int int rent[4] = {250, 375, 460, 600}; rent[2] and rent[4] = {250, 375}; rent[3] are set to 0 rent[3] = {250, 375, 460, 600}; Syntax error rent[4] = {0}; Sets all array elements to 0 8

Accessing and Using Array Values 9

Accessing and Using Array Values (continued) v. You can also use a variable as a subscript 10

Accessing and Using Array Values (continued) 11

Accessing and Using Array Values (continued) 12

Avoiding Common Array Errors v. When working with arrays, common errors include: § Forgetting that arrays are zero based § Accessing locations beyond the array 13

Forgetting that Arrays are Zero-Based 14

Accessing Locations Beyond the Array Element is out of bounds 15

Using Part of an Array Sentinel 16

Using Part of an Array (continued) v. Tip: You cannot use a variable to declare an array’s size; you must use a constant 17

Using Parallel Arrays v Parallel arrays are corresponding arrays in which values in the same relative locations are logically related 18

Using Parallel Arrays (continued) 19

Using Parallel Arrays (continued) 20

Using Parallel Arrays (continued) Flag could also be of type bool 21

Creating Arrays of Structure Objects 22

Using Strings v String: value expressed within double quotes v You can type two characters within single quotes when they represent a single character: ‘n’ v “Hello” is a string constant v To store a value such as “Hello” -> must create a string variable in one of two ways: § Create a string as an array of characters § Create a string using the string class defined in the C++ standard library 23

Strings Created as Arrays of Characters char char first. Name[] = “Mary”; Null character. You could first. Name[] = {“Mary”}; also use the constant NULL, defined in iostream first. Name[5] = “Mary”; first. Name[5] = {“Mary”}; first. Name[5] = {'M', 'a', 'r', 'y', ''}; cout<<first. Name; // displays Mary cout<<&first. Name[1]; // displays ary 24

Special String-Handling Problems When Using Character Arrays v. Some problems occur when strings are declared as character arrays and you: § Try to input a string value that includes whitespace § Try to assign one string to another using the assignment operator § Try to compare strings using the comparison operator § Exceed the bounds of an array 25

Trying to Input a String Value Including Whitespace 26

Trying to Input a String Value Including Whitespace (continued) 27

Trying to Assign One String to Another Using the Assignment Operator char club. President[10] = {“Eric”}; club. Vice. President[10] = {“Danielle”}; v. Alternative 1 (does not work as expected): club. President = club. Vice. President; v. Alternative 2 (tedious): club. President[0] = club. Vice. President[0]; club. President[1] = club. Vice. President[1]; club. President[2] = club. Vice. President[2]; v. Alternative 3 (must include string. h): strcpy(club. President, club. Vice. President); 28

Trying to Compare Strings Using the Comparison Operator v. Alternative 1 (does not work as expected): if(club. President == club. Vice. President) cout<<”They are the same”<<endl; v. Alternative 2 (tedious): if(club. President[0] == club. Vice. President[0] && club. President[1] == club. Vice. President[1]. . . v. Alternative 3 (must include string. h): strcmp(first. Name, sec. Name); A return value of 0 indicates they are equal 29

30

Exceeding an Array’s Bounds 31

Pitfall: Exceeding an Array’s Bounds (continued) 32

An Introduction to the string Class 33

An Introduction to the string Class (continued) 34

Using Pointers v. Pointers: variables that can hold memory addresses v. A pointer’s type indicates the type of variable that has an address the pointer can hold v. For example, int *a. Pointer; int my. Value; a. Pointer = &my. Value; cout<<my. Value; //outputs contents of my. Value cout<<*a. Pointer; //outputs contents of my. Value cout<<&my. Value; //outputs address of my. Value cout<<a. Pointer; //outputs address of my. Value 35

Pointer Variable Declarations and Initialization v. Can declare pointers to any data type v Pointer initialization § Initialized to 0, NULL, or address • 0 or NULL points to nothing 36

Pointer Operators v & (address operator) § Returns memory address of its operand § Example • int y = 5; • int *y. Ptr; • y. Ptr = &y; // y. Ptr gets address of y - y. Ptr “points to” y 37

Pointer Operators v* (indirection/dereferencing operator) § Returns synonym for object its pointer operand points to • *y. Ptr returns y (because y. Ptr points to y). • dereferenced pointer is 1 value • *yptr = 9; // assigns 9 to y v* and & are inverses of each other 38

Using const with Pointers v const qualifier § Value of variable should not be modified § const used when function does not need to change a variable v Principle of least privilege § Award function enough access to accomplish task, but no more v Four ways to pass pointer to function § Nonconstant pointer to nonconstant data • Highest amount of access § Nonconstant pointer to constant data § Constant pointer to nonconstant data § Constant pointer to constant data • Least amount of access 39

Using const with Pointers vconst pointers § Always point to same memory location § Default for array name § Must be initialized when declared 40

Example int main() { int x, y; // ptr is a constant pointer to an integer that can // be modified through ptr, but ptr always points to the // same memory location. int * const ptr = &x; //but if int const *ptr=&x then red line is error //and magenta line is not error *ptr = 7; // allowed: *ptr is not const ptr = &y; // error: ptr is const; cannot assign new address return 0; // indicates successful termination } // end main 41

Example int main() { int x = 5, y; // ptr is a constant pointer to a constant integer. // ptr always points to the same location; the integer // at that location cannot be modified. const int *const ptr = &x; cout << *ptr << endl; *ptr = 7; // error: *ptr is const; cannot assign new value ptr = &y; // error: ptr is const; cannot assign new address return 0; // indicates successful termination } // end main 42

Using a Pointer Instead of an Array Name 43

Using a Pointer Instead of an Array Name (continued) 44

You Do It: Using an Array 45

Understanding Memory Addresses cout << "The addresses are " << &first. Num <<" and " << &second. Num << endl; 46

Summary v Each location where a piece of data can be stored is identified by a memory address v A list of individual items that all have the same type is called an array v A subscript indicates the position of an array element v You can initialize an array when you declare it v You can access an individual array value just as you would access any variable of the same type 47

Summary (continued) v Common errors when using arrays include: § Forgetting that arrays are zero-based § Forgetting that the highest legitimate subscript is one less than the array size v Use a for loop to access all array elements v Parallel arrays contain corresponding elements v You can create arrays of structure objects 48

Summary (continued) v A C++ value expressed within double quotes is commonly called a string v You can create a string variable § As an array of characters § With the string class from the C++ standard library v Pointers are variables that hold memory addresses v To indicate a pointer, begin the variable’s name with an asterisk 49

Exercises v Binary search § Only used with sorted arrays § Compare middle element with key • If equal, match found • If key < middle – Repeat search on first half of array • If key > middle – Repeat search on last half 50

Exercises v. Bubble Sort Using Pass-by-Reference § Implement Bubble. Sort using pointers • Want function swap to access array elements – Individual array elements: scalars » Passed by value by default – Pass by reference using address operator & 51

Exercises v Tokenizing 52