Your SlideShare is downloading. ×

Lec2

921

Published on

Published in: Education
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
921
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
40
Comments
0
Likes
1
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Data Structures and Abstract Data Types Chapter 2
  • 2. Chapter Contents
    • 1 Data Structures, Abstract Data Types and Implementations
    • 2 Static Arrays
    • 3 Multidimensional Arrays (optional)
    • 4 Dynamic Arrays
    • 5 C-Style Structs (optional)
    • 6 Procedural Programming
  • 3. Chapter Objectives
    • Look at ADTs, implementations in detail
    • Introduce arrays as ADTs
    • See arrays implemented as C++ static arrays
    • (Optional) Describe multidimensional arrays
    • Extend pointers to use in dynamic arrays
    • (Optional) Show use of C++ structs to model objects with multiple attributes
    • Show example of procedural programming paradigm
  • 4. Data Structures, Abstract Data Types, and Implementations
    • Consider example of an airplane flight with 10 seats to be assigned
    • Tasks
      • List available seats
      • Reserve a seat
    • How to store, access data?
      • 10 individual variables
      • An array of variables
  • 5. Data Structures, Abstract Data Types, and Implementations
    • Implementation consists of
      • Storage (data) structures
      • Algorithms for basic operations
    • Note following figure
      • C++ provides large collection of data types and structures
  • 6. C++ Data Types structured array struct union class simple integral enum char short int long bool address pointer reference floating float double long double
  • 7. Structured Data Type
    • A structured data type is a type that
      • Stores a collection of individual components with one variable name
      • And allows individual components to be stored and retrieved by their position within the collection
  • 8. Arrays
    • Collection of data elements
      • All of same type
      • Each accessed by specifying position
    • Static array
      • Compiler determines how memory allocated
    • Dynamic array
      • Allocation takes place at run time
  • 9. Single Dimension Arrays
    • Syntax: ElementType arrayName [CAPACITY]; ElementType arrayName [CAPACITY] = { initializer_list };
    • Example: int b [10];
    • Elements accessed by
      • name and [ ] operation b[5]
  • 10. Character Arrays
    • Elements of an array may be of any type
      • Including characters
    • Example: char name [NAME_CAPACITY] = "John Doe";
    • If array initialized shorter than specs
      • extra locations filled with null character
  • 11. Subscript Operation
    • We have said elements accessed by name and [ ] numList[5]
    • Consider the [ ] to be an operator
      • The subscript operator
      • Performs address translation
    • Name of the array is a pointer constant
      • The base address
  • 12. Declare variables to store and total 3 blood pressures
    • int bp1, bp2, bp3;
    • int total;
    4002 4000 4004 bp2 bp1 bp3 cin >> bp1 >> bp2 >> bp3; total = bp1 + bp2 + bp3;
  • 13. What if you wanted to store and total 1000 blood pressures?
    • int bp[1000];
    • // Declares an array of 1000 int values
    bp[0] bp[1] bp[2] . . . . bp[999] 5000 5002 5004 5006 . . . .
  • 14. One-Dimensional Array Definition
    • An array is a structured collection of components (called array elements), all of the same data type, given a single name, and stored in adjacent memory locations
    • The individual components are accessed by using the array name together with an integral valued index in square brackets
    • The index indicates the position of the component within the collection
  • 15. Another Example
    • Declare an array called temps which will hold up to 5 individual float values
    • float temps[5]; // Declaration allocates memory
    temps[0] temps[1] temps[2] temps[3] temps[4] 7000 7004 7008 7012 7016 number of elements in the array indexes or subscripts Base Address
  • 16. Declaration of an Array
    • The index is also called the subscript
    • In C++, the first array element always has subscript 0, the second array element has subscript 1, etc.
    • The base address of an array is its beginning address in memory
    • SYNTAX
    • DataType ArrayName[ConstIntExpression];
  • 17. Yet Another Example
    • Declare an array called name which will hold up to 10 individual char values
    • char name[10]; // Declaration allocates memory
    number of elements in the array name[0] name[1] name[2] name[3] name[4] . . . . . name[9] 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 Base Address
  • 18. Assigning Values to Individual Array Elements
    • float temps[5]; int m = 4; // Allocates memory
    • temps[2] = 98.6;
    • temps[3] = 101.2;
    • temps[0] = 99.4;
    • temps[m] = temps[3] / 2.0;
    • temps[1] = temps[3] - 1.2;
    • // What value is assigned?
    temps[0] temps[1] temps[2] temps[3] temps[4] 7000 7004 7008 7012 7016 99.4 ? 98.6 101.2 50.6
  • 19. What values are assigned?
    • float temps[5]; // Allocates memory
    • int m;
    • for (m = 0; m < 5; m++)
    • {
    • temps[m] = 100.0 + m * 0.2 ;
    • }
    temps[0] temps[1] temps[2] temps[3] temps[4] 7000 7004 7008 7012 7016 ? ? ? ? ?
  • 20. Now what values are printed?
    • float temps[5]; // Allocates memory
    • Int m;
    • . . . . .
    • for (m = 4; m >= 0; m--)
    • {
    • cout << temps[m] << endl;
    • }
    temps[0] temps[1] temps[2] temps[3] temps[4] 7000 7004 7008 7012 7016 100.0 100.2 100.4 100.6 100.8
  • 21. Variable Subscripts
    • float temps[5]; // Allocates memory
    • int m = 3;
    • . . . . . .
    • What is temps[m + 1] ?
    • What is temps[m] + 1 ?
    temps[0] temps[1] temps[2] temps[3] temps[4] 7000 7004 7008 7012 7016 100.0 100.2 100.4 100.6 100.8
  • 22. A Closer Look at the Compiler
    • float temps[5]; // Allocates memory
    • To the compiler, the value of the identifier temps is the base address of the array
    • We say temps is a pointer (because its value is an address); it “points” to a memory location
    temps[0] temps[1] temps[2] temps[3] temps[4] 7000 7004 7008 7012 7016 100.0 100.2 100.4 100.6 100.8
  • 23. Initializing in a Declaration
    • int ages[5] ={ 40, 13, 20, 19, 36 };
    • for (int m = 0; m < 5; m++)
    • {
    • cout << ages[m];
    • }
    ages[0] ages[1] ages[2] ages[3] ages[4] 6000 6002 6004 6006 6008 40 13 20 19 36
  • 24. Passing Arrays as Arguments
    • In C++, arrays are always passed by reference
    • Whenever an array is passed as an argument, its base address is sent to the called function
  • 25. In C++, No Aggregate Array Operations
    • The only thing you can do with an entire array as a whole (aggregate) is to pass it as an argument to a function
    • Exception: aggregate I/O is permitted for C strings (special kinds of char arrays)
  • 26. Using Arrays as Arguments to Functions
    • Generally, functions that work with arrays require 2 items of information
      • The beginning memory address of the array (base address)
      • The number of elements to process in the array
  • 27. Example with Array Parameters #include <iomanip> #include <iostream> void Obtain (int[], int); // Prototypes here void FindWarmest ( const int[], int , int&); void FindAverage ( const int[], int , int&); void Print ( const int[], int); using namespace std; int main ( ) { // Array to hold up to 31 temperatures int temp[31] int numDays; int average; int hottest; int m;
  • 28. Example continued cout << “How many daily temperatures? ”; cin >> numDays; Obtain(temp, numDays); // Call passes value of numDays and address temp cout << numDays << “ temperatures“ << endl; Print (temp, numDays); FindAverage (temp, numDays, average); FindWarmest (temp, numDays, hottest); cout << endl << “Average was: “ << average << endl; cout << “Highest was: “ << hottest << endl; return 0; }
  • 29. Memory Allocated for Array int temp[31]; // Array to hold up to 31 temperatures temp[0] temp[1] temp[2] temp[3] temp[4] . . . . . temp[30] 6000 Base Address 50 65 70 62 68 . . . . . .
  • 30. void Obtain ( /* out */ int temp[] , /* in */ int number ) // User enters number temperatures at keyboard // Precondition: // number is assigned && number > 0 // Postcondition: // temp[0 . . number -1] are assigned { int m; for (m = 0; m < number; m++) { cout << “Enter a temperature : “; cin >> temp[m]; } }
  • 31. void Print ( /* in */ const int temp[], /* in */ int number ) // Prints number temperature values to screen // Precondition: // number is assigned && number > 0 // temp[0 . . number -1] are assigned // Postcondition: // temp[0 . . number -1] printed 5 per line { int m; cout << “You entered: “; for (m = 0; m < number; m++) { if (m % 5 == 0) cout << endl; cout << setw(7) << temp[m]; } }
  • 32. Using Arrays
    • Accessing array for output
      • See Fig. 1
    • Accessing array for input from keyboard
      • See Fig. 2
    • Note use of arrays as parameters
      • Must specify number of elements of array being used
  • 33. Figure1:Array Output Function
    • void display(int theArray[], int numValues)
    • /*-----------------------------------------------------------------
    • Display values in an array of integers. Precondition: 0 <= numValues < capacity of theArray. Postcondition: The first numValues integers stored in theArray have been output to cout.
    • -------------------------------------------------------------------------*/
    • {
    • for (int i = 0; i < numValues; i++)
    • cout « theArray[i] « 00 &quot; .
    • cout « endl;
    • }
  • 34. Figure 2: Array Input Function #include <cassert> void read(IntArray theArray, int capacity, int numValues) /*------------------------------------------------------------------------- Input values into an array of integers from the keyboard. Preconditions: 0 <= numValues < capacity, which is the capacity of theArray. Postcondition: numValues integers entered from the keyboard have been stored in the first NumValues positions of theArray -------------------------------------------------------------------------/* { assert (numValues >= 0 && numValues <= capacity); for (int i = 0; i < numValues; i++) cin » theArray[i] ; }
  • 35. #include <iostream> using namespace std; void main() { int Nums[4]; int Sum=0; cout<<&quot;Enter 4 Numbers :n&quot;; for(int i=0;i<4;i++) cin>>Nums[i]; for(int j=0;j<4;j++) Sum+=Nums[j]; cout<<&quot;Sum = &quot;<<Sum<<endl; }
  • 36. Multidimensional Arrays
    • Consider multiple pages of the student grade book const int NUM_ROWS = 10, NUM_COLS = 5, NUM_RANKS = 10; typedef double ThreeDimArray[NUM_ROWS][NUM_COLS][NUM_RANKS];
    . . .
  • 37. Example on Multidimensional Arrays
    • #include <iostream> using namespace std;
    • int main()
    • {
    • // A 2-Dimensional array
    • double distance[2][4] = {44.14, 720.52, 96.08, 468.78, 6.28, 68.04, 364.55, 6234.12};
    • // Scan the array from the 3rd to the 7th member
    • cout << &quot;Members of the array&quot;;
    • cout << &quot;nDistance [0][0]&quot; << &quot;: &quot; << distance[0][0];
    • cout << &quot;nDistance [0][1]&quot; << &quot;: &quot; << distance[0][1];
    • cout << &quot;nDistance [0][2]&quot; << &quot;: &quot; << distance[0][2];
    • cout << &quot;nDistance [0][3]&quot; << &quot;: &quot; << distance[0][3];
    • cout << &quot;nDistance [1][0]&quot; << &quot;: &quot; << distance[1][0];
    • cout << &quot;nDistance [1][1]&quot; << &quot;: &quot; << distance[1][1];
    • cout << &quot;nDistance [1][2]&quot; << &quot;: &quot; << distance[1][2];
    • cout << &quot;nDistance [1][3]&quot; << &quot;: &quot; << distance[1][3];
    • cout << endl; return 0;
    • }
    • This would produce: Members of the array
    • Distance [0][0]: 44.14 Distance [0][1]: 720.52
    • Distance [0][2]: 96.08 Distance [0][3]: 468.78
    • Distance [1][0]: 6.28 Distance [1][1]: 68.04
    • Distance [1][2]: 364.55 Distance [1][3]: 6234.12
  • 38. Array of Array Declarations
    • An array of arrays
      • An array whose elements are other arrays
  • 39. Array of Array Declarations
    • Each of the rows is itself a one dimensional array of values
    scoresTable[2] is the whole row numbered 2 scoresTable [1][3]
  • 40. Memory Allocation in 2-Dimensional Arrays
    • Elements stored in rowwise order
    • Also called column major order
    location [0][4] is followed in memory by location [1][0]

×