Review RecordsDynamic Memory and Pointers

Introduction to Linked Lists

Review: Records

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 numEndrecord

Student_Type definesa record name isoftype string gpa isoftype num birth_day isoftype Date_Type graduation_day isoftype Date_Typeendrecord

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

Record Within Records

Date_Type:

Student_Type:

bob isoftype Student_Typebob.birth_day.month <- 6

day month year

day month year

name gpa

day month yearbirth_day

graduation_day

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

Dynamic Memory and Pointers

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.

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.

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.

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 QueuesAirlinersuh, everything?

Examples?Printer QueuesAirlinersuh, everything?

A View of Memory

Algorithm and Module Code(What you wrote)

Stack (Static Area)(Store stuff here)

Heap (Dynamic Area)(Store stuff here)

LB

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)

The Stack

• Recall the activation stack– The stack can expand, but as for the data…– Each frame contains static (fixed size) data

Algo var1 var2 var3

Proc_1 this_var that_var

The number ofvariables neededcome from the“isoftype” statements.

The Stack and Heap

Main this_var that_var my_num_ptr4 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

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

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)

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

Ptr1 isoftype Ptr toa NumPtr2 isoftype Ptr toa NumPtr1 <- new(Num)Ptr1^ <- 5Ptr2 <- Ptr1Print(Ptr1^, Ptr2^)Ptr2^ <- 7Print(Ptr1^, Ptr2^)

Num

5 55 57 7

Ptr1

Ptr

Ptr2

Ptr

57

Pointer Animation of Numbers

static dynamic

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

Pointers and Records

currentBob

123456789

static dynamic

current

Pointers and Records

current

current^

Bob

123456789

static dynamic

Pointers and Records

current

current^.name <- “Bob”

Bob

123456789

static dynamic

Pointers and Records

current

current^.SSN <- 123456789

Bob

123456789

static dynamic

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

Questions?

Introduction to Linked Lists

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)

Linked Lists “Live” in the Heap

Main this_var list_head4

12 18 21 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

Linked Lists

With pointers, we can form a “chain” of data structures:

List_Node definesa Record data isoftype Num next isoftype Ptr toa List_Nodeendrecord //List_Node

4 17 42

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

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)

Pointers and Linked Lists

current

current^

current^.next

current^.data

static dynamic

Accessing the Data Field of a Node

current

current^.data <- 42

current^.next <- NIL

42

static dynamic

Proper Data Abstraction

Vs.

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_Typeendrecord // Node_Rec_Type

Complex Data Records and Lists

LB

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_Typeendrecord // Node_Data_Type

Node_Record_Type definesa Record data isoftype Node_Data_Type next isoftype Ptr toa Node_Rec_Typeendrecord // Node_Record_Type

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

?

Creating a New Node in the List

list_head <- new(List_Node)

Main list_head

?

Filling in the Data Field

list_head^.data <- 42

The ^ operator follows the pointer into the heap.

Main list_head

?42

Creating a Second Node

list_head^.data <- 42list_head^.next <- new(List_Node)

The “.” operator accesses a field of the record.

Main list_head

42 ?

Cleanly Terminating the Linked List

list_head^.next^.data <- 91list_head^.next^.next <- NIL

We terminate linked lists “cleanly” using NIL.

Main list_head

42 91

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

42 91

Questions?