1 / 45

Review Records Dynamic Memory and Pointers Introduction to Linked Lists

Lecture 8. Review Records Dynamic Memory and Pointers Introduction to Linked Lists. Review: Records. This name is now a type which can be used anywhere a type such as “Num” can be used. What are these called?. Types. LB. Records Within Records.

teagan-obrien
Download Presentation

Review Records Dynamic Memory and Pointers Introduction to Linked Lists

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Lecture 8 Review RecordsDynamic Memory and PointersIntroduction to Linked Lists

  2. Review: Records

  3. This name is now a type which can be used anywhere a type such as “Num” can be used. What are these called? Types LB Records Within Records There is nothing to prevent us from placing records inside of records (a field within a record): Date_Type definesa record day, month, year isoftype num Endrecord Student_Type definesa record name isoftype string gpa isoftype num birth_day isoftype Date_Type graduation_day isoftype Date_Type endrecord

  4. day month year name gpa day month year day month year Record Within Records Date_Type: Student_Type: bob isoftype Student_Type bob.birth_day.month <- 6 birth_day graduation_day

  5. Types vs. Variables • TYPE Definitions • Create templates for new kinds of variables • Do not create a variable – no storage space is allocated • Have unlimited scope • VARIABLE Declarations • Actually create storage space • Have limited scope - only module containing the variable can “see” it • Must be based on an existing data type

  6. Dynamic Memory and Pointers

  7. Dynamic vs. Static Static (fixed in size) • Sometimes we create data structures that are “fixed” and don’t need to grow or shrink. Dynamic (change in size) • Other times, we want the ability to increase and decrease the size of our data structures to accommodate changing needs.

  8. Staticdata is data declared “ahead of time.” It is declared in a module (or main algorithm) and “lives” for as long as that module is active. If we declare more static variables than we need, we waste space. If we declare fewer static variables than we need, we are out of luck. Often, real world problems mean that we don’t know how many variables to declare, as the number needed will change over time. Static Data

  9. Dynamic Data • Dynamic data refers to data structures which can grow and shrink to fit changing data requirements. • We can allocate (create) additional dynamic variables whenever we need them. • We can de-allocate (kill) dynamic variables whenever we are done with them. • A key advantage of dynamic data is that we can always have a exactly the number of variables required - no more, no less. • For example, with pointer variables to connect them, we can use dynamic data structures to create a chain of data structures called a linked list.

  10. LB Note • Dynamic data gives us more flexibility • Memory is still limited • But now we can use it where we need it • And we can determine that while the program is running Examples? Printer Queues Airliners uh, everything?

  11. Heap (Dynamic Area) (Store stuff here) Stack (Static Area) (Store stuff here) Algorithm and Module Code (What you wrote) LB A View of Memory

  12. A List Example • We must maintain a list of data • Sometimes we want to use only a little memory: • Sometimes we need to use more memory • Declaring variables in the standard way won’t work here because we don’t know how many variables to declare • We need a way to allocate and de-allocate data dynamically (i.e., on the fly)

  13. Proc_1 this_var that_var Algo var1 var2 var3 The Stack • Recall the activation stack • The stack can expand, but as for the data… • Each frame contains static (fixed size) data The number of variables needed come from the “isoftype” statements.

  14. What kind of variable is this??? LB The Stack and Heap 12 Heap Main this_var that_var my_num_ptr 7 4 The heap is memory not used by the stack As stack grows, heap shrinks Static variables live in the stack Dynamic variables live in the heap Stack

  15. LB What? • We know (sort of) how to get a pointer variable my_num_ptr isoftype Ptr toa Num • But how do we get it to point at something?

  16. The Built-In Function NEW() • Takes a type as a parameter • Allocates memory in the heap for the type • Returns a pointer to that memory my_num_ptr <- new(Num) dynamic_string <- new(String) list_head <- new(Node)

  17. Accessing Dynamic Data via Pointers 43 Heap: Dynamic • When we “follow a pointer”, we say that we dereference that pointer • The carat (^) means “dereference the pointer” • my_num_ptr^ means ”follow my_num_ptr to wherever it points” • My_num_ptr^ <- 43 is valid Main my_num_ptr Stack: Static

  18. Ptr1 isoftype Ptr toa Num Ptr2 isoftype Ptr toa Num Ptr1 <- new(Num) Ptr1^ <- 5 Ptr2 <- Ptr1 Print(Ptr1^, Ptr2^) Ptr2^ <- 7 Print(Ptr1^, Ptr2^) Pointer Animation of Numbers 5 5 5 5 7 7 Num Ptr Ptr1 5 7 Ptr Ptr2 static dynamic

  19. name SSN A record to hold two items of data - a name and a SSN: Student definesa record name isoftype String SSN isoftype num endrecord And a pointer to a Student record: current isoftype ptr toa Student current <- new(Student)

  20. Pointers and Records Bob current 123456789 static dynamic current

  21. Pointers and Records Bob current 123456789 static dynamic current^

  22. Pointers and Records Bob current 123456789 static dynamic current^.name <- “Bob”

  23. Pointers and Records Bob current 123456789 static dynamic current^.SSN <- 123456789

  24. LB What’s the big deal • We already knew about static data • Now we see we can allocate dynamic data but • Each piece of dynamic data seems to need a pointer variable and pointers seem to be static • So how can this give me flexibility

  25. Questions?

  26. Introduction to Linked Lists

  27. Properties of Lists • We must maintain a list of data • Sometimes we want to use only a little memory: • Sometimes we need to use more memory • Declaring variables in the standard way won’t work here because we don’t know how many variables to declare • We need a way to allocate and de-allocate data dynamically (i.e., on the fly)

  28. 12 18 21 23 Linked Lists “Live” in the Heap Heap Stack Main this_var list_head 4 The heap is memory not used by the stack Dynamic variables live in the heap We need a pointer variable to access our list in the heap

  29. Linked Lists With pointers, we can form a “chain” of data structures: List_Node definesa Record data isoftype Num next isoftype Ptr toa List_Node endrecord //List_Node 4 17 42

  30. Linked List Record Template <Type Name> definesa record data isoftype <type> next isoftype ptr toa <Type Name> endrecord Example: Char_Node definesa record data isoftype char next isoftype ptr toa Char_Node endrecord

  31. Creating a Linked List Node Node definesa record data isoftype num next isoftype ptr toa Node endrecord And a pointer to a Node record: current isoftype ptr toa Node current <- new(Node)

  32. current^.data current^.next Pointers and Linked Lists current static dynamic current^

  33. Accessing the Data Field of a Node 42 current static dynamic current^.data <- 42 current^.next <- NIL

  34. Proper Data Abstraction Vs.

  35. LB Complex Data Records and Lists The examples so far have shown a single num variable as node data, but in reality there are usually more, as in: Node_Rec_Type definesa record this_data isoftype Num that_data isoftype Char other_data isoftype Some_Rec_Type next isoftype Ptr toa Node_Rec_Type endrecord // Node_Rec_Type pda(5)

  36. A Better Approach with Higher Abstraction One should separate the data from the structure that holds the data, as in: Node_Data_Type definesa Record this_data isoftype Num that_data isoftype Char other_data isoftype Some_Rec_Type endrecord // Node_Data_Type Node_Record_Type definesa Record data isoftype Node_Data_Type next isoftype Ptr toa Node_Rec_Type endrecord // Node_Record_Type

  37. Creating a Pointer to the Heap ? list_head isoftype ptr toa List_Node Notice that list_head is not initialized and points to “garbage.” Main list_head

  38. Creating a New Node in the List ? list_head <- new(List_Node) Main list_head

  39. Filling in the Data Field ? list_head^.data <- 42 The ^ operator follows the pointer into the heap. 42 Main list_head

  40. Creating a Second Node ? list_head^.data <- 42 list_head^.next <- new(List_Node) The “.” operator accesses a field of the record. 42 Main list_head

  41. Cleanly Terminating the Linked List list_head^.next^.data <- 91 list_head^.next^.next <- NIL We terminate linked lists “cleanly” using NIL. 42 91 Main list_head

  42. Deleting by Moving the Pointer If there is nothing pointing to an area of memory in the heap, it is automatically deleted. list_head <- list_head^.next 42 91 Main list_head

  43. Questions?

More Related