02 c++ Array Pointer
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

02 c++ Array Pointer

on

  • 3,503 views

 

Statistics

Views

Total Views
3,503
Views on SlideShare
3,494
Embed Views
9

Actions

Likes
1
Downloads
113
Comments
0

1 Embed 9

http://www.slideshare.net 9

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

02 c++ Array Pointer Presentation Transcript

  • 1. Understanding Arrays and Pointers Object-Oriented Programming Using C++ Second Edition 3
  • 2. 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
    3
  • 4. 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
    3
  • 5. Using the Address Operator 3 F3-1.cpp //console I/O
  • 6. 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
    3 F3-3.cpp & F3-4.cpp
  • 7. 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
    3
  • 8. 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
    3
  • 9. 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
    3
  • 10. 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
    3
  • 11. 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
    3
  • 12. Program that Uses Single and Array Variables 3 F3-6.cpp
  • 13. 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
    3
  • 14. 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
    3
  • 15. Accessing and Using Array Values 3
  • 16. 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
    3
  • 17. Using a Constant to Control Loops 3 F3-10.cpp
  • 18. 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
    3
  • 19. A Program That Averages Up to 30 Test Scores 3 F3-11.cpp
  • 20. 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
    3
  • 21. A Program That Determines Insurance Premiums 3 F3-12.cpp
  • 22. 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
    3
  • 23. 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
    3
  • 24. Program That Determines Part Prices 3 F3-14.cpp F3-14.cpp
  • 25. 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
    3
  • 26. 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
    3
  • 27. Creating an Array of Class Objects 3 F3-15
  • 28. Output of Program from Figure 3-16 3
  • 29. 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
    3
  • 30. 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
    3
  • 31. Using Strings
      • The null character is represented by the combination ‘’ (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
    3
  • 32. 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
    3
  • 33. A Program That Reads a Name 3
  • 34. 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
    3
  • 35. Special String Handling Problems 3
  • 36. 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
    3
  • 37. 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]. . .
    3
  • 38. Using the strcmp() Function 3 F3-23.cpp
  • 39. 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
    3
  • 40. 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
    3
  • 41. 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
    3
  • 42. A Program That Uses Array and Pointer Notation 3 F3-25.cpp
  • 43. Output of Program From Figure 3-25 3
  • 44. Using Pointers to Hold Strings 3 F3-27.cpp
  • 45. 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
    3