1. More on Dynamic Memory Allocation Seokhee Jeon Department of Computer Engineering Kyung Hee University 1 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

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

3. Pointing to Memory Allocated at Run Time

4. Using Memory Allocated at Run Time

5. Run Time Allocation of Arrays

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

8. Returning Memory to the Heap

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

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

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

12. Returning Memory to the Heap

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

14. Memory Leak

16. Memory Efficiency 16

17. Linked Lists in C and C++ CS-2303 System Programming Concepts (Slides include materials from The C Programming Language, 2 nd edition, by Kernighan and Ritchie and from C: How to Program, 5 th and 6 th editions, by Deitel and Deitel) 17

18. 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 Note: elements are usually the same type (but not always).

19. Linked List struct listItem { type payload; struct listItem *next; }; 19 payload next payload next payload next payload next Note: payload may be multiple members.

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

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

22. Linked List (continued) struct listItem { type payload; struct listItem *next; }; struct listItem *head; 22 payload next payload next payload next payload next

23. 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 23 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; } 24 payload next payload next payload next payload next payload next

25. Adding an Item to a List listItem *addAfter(listItem *p, listItem *q){ q -> next = p -> next; p -> next = q; return p; } 25 payload next payload next payload next payload next payload next

26. Adding an Item to a List listItem *addAfter(listItem *p, listItem *q){ q -> next = p -> next; p -> next = q; return p; } 26 payload next payload next payload next payload next payload next Question: What to do if we cannot guarantee that p and q are non-NULL?

27. 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; } 27 payload next payload next payload next payload next payload next Note test for non-null p and q

28. What about Adding an Item before another Item? struct listItem *p; Add an item before item pointed to by p ( p != NULL ) 28 payload next payload next payload next payload next payload next

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

30. Doubly-Linked List struct listItem { type payload; listItem *prev; listItem *next; }; struct listItem *head, *tail; 30 prevnext payload prevnext payload prevnext payload prevnext payload In-class exercise:– how to add a new item q after a list item p

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

32. Circular List 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 payload next payload next payload next payload next struct listItem *tail; Optional:– struct listItem *head;