1. Review Records Dynamic Memory and Pointers Introduction to Linked Lists

3. Review: Records

4. 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 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

5. Record Within Records Date_Type: Student_Type: bob isoftype Student_Type bob.birth_day.month <- 6 day month year namegpa day month year birth_day graduation_day

6. 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

7. Dynamic Memory and Pointers

8. 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.

9. Static Data Static data 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.

10. 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.

11. 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 LB Examples? Printer Queues Airliners uh, everything?

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

13. 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)

14. The Stack Recall the activation stack –The stack can expand, but as for the data… –Each frame contains static (fixed size) data Algo var1var2var3 Proc_1 this_varthat_var The number of variables needed come from the “isoftype” statements.

15. The Stack and Heap Main this_var that_var my_num_ptr 4 7 12 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 What kind of variable is this??? Heap Stack LB

16. 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? LB

17. 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)

18. Accessing Dynamic Data via Pointers 43 Main my_num_ptr 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 Heap: Dynamic Stack: Static

19. 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^) Num 5 7 Ptr1 Ptr Ptr2 Ptr 57 Pointer Animation of Numbers staticdynamic

20. 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) name SSN

21. Pointers and Records current Bob 123456789 staticdynamic current

22. Pointers and Records current current^ Bob 123456789 staticdynamic

23. Pointers and Records current current^.name <- “Bob” Bob 123456789 staticdynamic

24. Pointers and Records current current^.SSN <- 123456789 Bob 123456789 staticdynamic

25. 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 LB

26. Questions?

27. Introduction to Linked Lists

28. 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)

29. Linked Lists “Live” in the Heap Main this_var list_head 4 121821 23 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 Heap Stack

30. 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 41742

31. Linked List Record Template definesa record data isoftype next isoftype ptr toa endrecord Example: Char_Node definesa record data isoftype char next isoftype ptr toa Char_Node endrecord

32. 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)

33. Pointers and Linked Lists current current^ current^.next current^.data staticdynamic

34. Accessing the Data Field of a Node current current^.data <- 42 current^.next <- NIL 42 staticdynamic

35. Proper Data Abstraction Vs.

36. 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 Complex Data Records and Lists LB

37. 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

38. 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 ?

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

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

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

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

43. 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 Main list_head 4291

44. Questions?