Dynamic allocation (continued) EECE.3220 Data Structures Instructor: Dr. Michael Geiger Spring 2019 Lecture 19: Dynamic allocation (continued) Stacks

Announcements/reminders Program 2 due 3/21 Exam 2: Monday, 4/1, 3-5 PM, Ball 214 Use same poll as before to request alt. exam (I’ll repost link) Today’s lecture Review: dynamic allocation Linked data structures Stacks 4/28/2019 Data Structures: Lecture 19

Review: Dynamic allocation with new Use new to dynamically allocate space new int allocates space for 1 integer new int[20] allocates an array of 20 integers new “returns” pointer to first byte Directly initialize with value in parentheses e.g. new int(3) Pointer must hold address generated by new int *p1 = new int(3); // p1  single int = 3 int *p2 = new int[20]; // p2  array of 20 // ints 4/28/2019 Data Structures: Lecture 19

Review: Dynamically allocated objects May want to dynamically allocate objects Ex. array of Points where size is unknown at compile time Point *pointArray; int numPoints; cin >> numPoints; pointArray = new Point[numPoints]; Ex. linked list data structure—to add an element to the list, must allocate new element class linkedList { private: int elem; linkedList *next; public: linkedList(); linkedList(int val); void addElement(int i); ... } void linkedList::addElement(int i) { next = new linkedList(i); 4/28/2019 Data Structures: Lecture 19

Review: Referencing objects thru pointers Recall: use dot operator (.) to reference members of object, e.g: Point p1; p1.setX(2); With pointers, use -> linkedList *list1 = new linkedList; list1->addElement(2); 4/28/2019 Data Structures: Lecture 19

Deallocation with delete Space allocated using new should be freed In C, we used free() In C++, we use delete You should only use delete to free memory allocated by new Any other use will result in an error 4/28/2019 Data Structures: Lecture 19

Data Structures: Lecture 19 delete example int *ptr; ptr = new int (100); ptr 100 delete ptr; //free the memory ptr ? delete frees space on heap ... ... but ptr still points to same address! Solution: assign freed pointers to NULL: ptr = NULL; 4/28/2019 Data Structures: Lecture 19

Example: delete with arrays double *dptr; const int SIZE = 10; dptr = new double[SIZE]; //80 bytes for(int i=0; i<SIZE; ++i) cin >> dptr[i]; fun1(dptr, SIZE); // pass array to fun1 delete [] dptr; //free all 10 elements dptr = NULL; 4/28/2019 Data Structures: Lecture 19

Data Structures: Lecture 19 List ADT Common problem in program: store collection—or list—of things Grocery list, grade list, list of students, etc. Common properties Homogeneous (elements all have same type) Finite length (number of elements) Length could be 1 or even 0 Elements arranged sequentially Well-defined first and last element All except last have unique successor All except first have unique predecessor 4/28/2019 Data Structures: Lecture 19

Data Structures: Lecture 19 List ADT (continued) A sequence of a finite number of data items, all of the same type Basic operations Construction: create empty list Empty: check if the list is empty Insert: add an item to the list Delete: remove an item from the list Traverse: go through part or all of list, accessing and processing elements in order Types of traversal include search, output (to screen or file), copy, rearrange (usually sort) 4/28/2019 Data Structures: Lecture 19

List-based data structures List ADT used for several data structures Differences between them Where can data be inserted? Where can data be removed? What determines ordering of items? List-based data structures Stacks: insert/remove at “top” (LIFO) Queue: insert at back, remove at front (FIFO) Linked list: insert/remove anywhere, can order as needed 4/28/2019 Data Structures: Lecture 19

Data Structures: Lecture 19 Array-based lists Implementing ADT Define necessary data members Define methods described in ADT design Common list implementation: array Built-in type in most languages Sequential memory storage Straightforward algorithms For (some) flexibility, dynamically allocate array Define max size of list at construction Dynamic allocation does cause some issues with construction (to be seen) 4/28/2019 Data Structures: Lecture 19

Data Structures: Lecture 19 Stacks Consider the following applications Run-time memory management On function call, create space for local data (stack frame or activation record) On return, clear frame for current function Traversing maze Follow path until dead end Backtrack to last intersection and choose new path In all cases Need ability to access only most recent data If necessary, will only remove most recent data Appropriate data structure: stack 4/28/2019 Data Structures: Lecture 19

Data Structures: Lecture 19 Stack ADT Stack is last-in, first-out (LIFO) data structure Definition Ordered collection of data items Can only be accessed at one end (top of stack) Operations Construction (start with empty stack) Check if stack is empty Push: add data to the top of the stack Pop: remove data from the top of the stack Read item at top of stack 4/28/2019 Data Structures: Lecture 19

Data Structures: Lecture 19 Final notes Next time: more on stacks Details of array-based implementation Dynamic allocation, constructors, and destructors Operator overloading Reminders: Program 2 due 3/21 Exam 2: Monday, 4/1, 3-5 PM, Ball 214 Use same poll as before to request alt. exam (I’ll repost link) 4/28/2019 Data Structures: Lecture 19