Transcript Linked Lists in C and C++

More on Dynamic Memory Allocation
Seokhee Jeon
Department of Computer Engineering
Kyung Hee University
Illustrations, examples, and text in the lecture note courtesy of Prof. David Bernstein,
https://users.cs.jmu.edu/bernstdh/web/common/lectures/slides_cpp_dynamic-memory.php
•1
Reminders
• Dynamically allocated memory is kept on the
memory heap
• Dynamically allocated memory can't have a "name" it
must be referred by pointers
• Declarations are used to statically allocate memory,
the new operator is used to dynamically allocate
memory
Pointing to Memory Allocated at Run
Time
Using Memory Allocated at Run Time
Run Time Allocation of Arrays
Run Time Allocation of Arrays
Returning Memory to the Heap
• How Big is the Heap?
– It can only contain as much physical memory as you have
installed or as much virtual memory as your operating
system can make available (if it supports virtual memory)
• Running Out of Memory:
– Most applications request memory from the heap when
they are running
– It is possible to run out of memory (you may even have
gotten a message like "Running Low On Virtual Memory")
– So, it is important to return memory to the heap when you
no longer need it
Returning Memory to the Heap
Returning Memory to the Heap
• Dangling Pointers:
– The delete operator does not
delete the pointer, it takes the
memory being pointed to and
returns it to the heap
– It does not even change the
contents of the pointer
– Since the memory being
pointed to is no longer
available (and may even be
given to another application),
such a pointer is said to be
dangling
Returning Memory to the Heap
• Remember:
– Return memory to the heap before undangling the
pointer
• What's Wrong with the Following:
– ptr = NULL;
– delete ptr;
Returning Memory to the Heap
• What About Arrays?
– You want to return all of the memory to the heap
– So, a different form of the delete operator is
needed
– Also, the memory allocator must keep track of the
size of the array
Returning Memory to the Heap
Memory Leak
• Memory leaks when it is
allocated from the heap
using the new operator
but not returned to the
heap using the delete
operator
Memory Leak
Memory Leak
Memory Efficiency
16
Linked Lists in C and C++
CS-2303
System Programming Concepts
(Slides include materials from The C Programming Language, 2nd edition, by Kernighan and Ritchie and
from C: How to Program, 5th and 6th editions, by Deitel and Deitel)
•17
Definitions
• Linked List
• A data structure in which each element is
dynamically allocated and in which elements
point to each other to define a linear
relationship
• Singly- or doubly-linked
• Stack, queue, circular list
18
Linked List
struct listItem {
type payload;
struct listItem *next;
};
payload
next
payload
next
payload
next
payload
next
19
Linked List (continued)
• Items of list are usually same type
• Generally obtained from new operator
• Each item points to next item
• Last item points to null
• Need “head” to point to first item!
• “Payload” of item may be almost anything
•
•
•
•
A single member or multiple members
Any type of object whose size is known at compile time
Including struct, union, char * or other pointers
Also arrays of fixed size at compile time (see p. 214)
20
Usage of Linked Lists
• Not massive amounts of data
• Linear search is okay
• Sorting not necessary
• or sometimes not possible
• Need to add and delete data “on the fly”
• Even from middle of list
• Items often need to be added to or deleted from the
“ends”
21
Linked List (continued)
struct listItem {
type payload;
struct listItem *next;
};
struct listItem *head;
payload
next
payload
next
payload
next
payload
next
22
Adding an Item to a List
struct listItem *p, *q;
• Add an item pointed to by q after item pointed to by p
– Neither p nor q is NULL
payload
next
payload
next
payload
next
payload
next
payload
next
23
Adding an Item to a List
listItem *addAfter(listItem *p, listItem *q){
q -> next = p -> next;
p -> next = q;
return p;
}
payload
next
payload
next
payload
next
payload
next
payload
next
24
Adding an Item to a List
listItem *addAfter(listItem *p, listItem *q){
q -> next = p -> next;
p -> next = q;
return p;
}
payload
next
payload
next
payload
next
payload
next
payload
next
25
Adding an Item
a toList
Question:to
What
do if we cannot
guarantee that p and q are non-NULL?
listItem *addAfter(listItem *p, listItem *q){
q -> next = p -> next;
p -> next = q;
return p;
}
payload
next
payload
next
payload
next
payload
next
payload
next
26
Adding an Item to a List (continued)
listItem *addAfter(listItem *p, listItem *q){
if (p && q) {
q -> next = p -> next;
p -> next = q;
}
return p;
}
payload
next
payload
next
payload
next
payload
next
payload
next
27
What about Adding an Item
before another Item?
struct listItem *p;
• Add an item before item pointed to by p (p != NULL)
payload
next
payload
next
payload
next
payload
next
payload
next
28
What about Adding an Item
before another Item?
• Answer:–
– Need to search list from beginning to find previous
item
– Add new item after previous item
• This is needed in PA#3
– Insert item after earlier event times and before
later ones
– Need to search the list
29
Doubly-Linked List
struct listItem {
type payload;
listItem *prev;
listItem *next;
};
struct listItem *head, *tail;
payload
prev
payload
prev
next
payload
prev
next
payload
prev
next
next
30
Other Kinds of List Structures
• Queue — FIFO (First In, First Out)
• Items added at end
• Items removed from beginning
• Stack — LIFO (Last In, First Out)
• Items added at beginning, removed from
beginning
• Circular list
• Last item points to first item
• Head may point to first or last item
• Items added to end, removed from beginning
31
Optional:–
struct listItem *head;
Circular List
struct listItem *tail;
payload
payload
next
next
payload
next
payload
next
listItem *addAfter (listItem *p, listItem *tail){
if (p && tail) {
p -> next = tail -> next;
tail = p;
} else if (p) {
tail p -> next = p;
}
return tail;
}
32