EECS 281 Data Structures and Algorithms - University of Michigan –Final Cheat Sheet

downloaded from

Scholarfriends

https://scholarfriends.com Downloaded by: writerforacademic@gmail.com | https://scholarfriends.com/singlePaper/314669/eecs-281-data-structures-and-algorithmsuniversity-of-michigan-final-cheat-sheet Distribution of this document is illegal.

EECS 280 –Final Cheat Sheet Const Keyword (Read Inside-Out):  Const pointer: const int *ptr = &x;  Pointer-to-const: int * const ptr = &x;  double perimeter const {}, where const means the function will not modify any member variables Arrays:  arr[i] is equivalent to *(arr + i)  Traversal by pointer: for (int *ptr = arr; ptr < arr + SIZE; ++ptr) { } Container ADTs:  A container is an ADT whose purpose is to hold other objects. (ex. arrays, vectors)  Representation Invariants - express the conditions for a valid compound object.  Static keyword - data member with this modifier is shared between all instances of the class o Lives throughout the program, but within the class's scope.  size_t (unsigned integer) - guaranteed to hold members large enough to represent the largest possible size of an object or a container  Operator Overloading - overloading of operators to tell them what to do (help handle non-primitive types) o std::ostream & operator<<(std::ostream &os, const T &item) // Insertion Operator o value_t & operator[](std::size_t index) // Subscript Operator o T & operator=(const T &other) // Assignment Operator o bool operator< (const Iterator &lhs, const Iterator &rhs) // Less than Operator Templates:  The compiler can see which kinds of the class you use and instantiates (produces) a version of the code for each different type T.  template <typename T> using Set = UnsortedSet<T>; // Type Aliasing  template <typename T> void fillFromArray(Set<T> &set, const T *arr, int n); // Template Parameter List  Template instantiation is done during compilation proper, which is before the linking phase.

Managing Dynamic Memory (Requires BIG THREE):  When a class-type object is created, its constructor runs. (top-down behavior) o For a local object, when its declaration runs. o For a dynamic object, when it is created with new.  When a class-type object dies, its destructor runs. (bottom-up behavior) o For a local object, when it goes out of scope. o For a dynamic object, when it is destroyed with delete.  The lifetimes of the members of a class-type object are tied to the lifetime of the whole object itself. o After its body executes, the destructor of a class-type object automatically runs the destructors of its members that are of class type.  Memory Leaks - You’re not using dynamic memory, but you never free up the space for it.  Orphaned Memory - You lose the address of a heap object, meaning it will inevitably be leaked.  Double Free - You try to free heap memory too many times.  Bad Delete - Use delete with a pointer to a non-heap object.  Dangling Pointers - You keep around the address of a dead heap object.  Special syntax for deleting arrays: delete[] arr; // Deletes array, not the pointer. Other methods won’t work.

Deep Copies and The Big Three (Destructor, Copy Constructor, Assignment Operator):  Destructors – deallocate dynamically allocated memory // Implicit – basic clearing of local variables o If there are subtypes, ALWAYS make the destructor virtual.  Copy Constructor – initializes a compound from another (makes a deep copy) // Implicit – shallow copy of other o Also used when an object is passed by value in parameter passing UnsortedSet(const UnsortedSet &other) : elts(new T[other.capacity]), capacity(other.capacity), elts_size(other.elts_size) { // 1. Copy regular members from other for (int i = 0; i < elts_size; ++i) { elts[i] = other.elts[i]; } // 2. Deep copy resources from other }  Assignment Operator – Assigning the value of one compound object to another // Implicit – shallow copy of other UnsortedSet & operator=(const UnsortedSet &rhs) { if (this == &rhs) { return *this; } // 1. Check for self-assignment delete[] elts; // 2. Free old resources capacity = rhs.capacity; // 3. Copy regular members from rhs elts_size = rhs.elts_size; elts = new T[rhs.capacity]; for (int i = 0; i < elts_size; ++i) { elts[i] = rhs.elts[i]; } // 4. Deep copy resources from rhs return *this; // 5. return *this } Linked List:  Allows data storage in non-contiguous memory; can be singly, doubly, or tree linked void pop_front() { // Delete front node on singly linked list assert(!empty()); Node *victim = first; // Place-holder pointer first = first->next; delete victim; } Iterators - An object that acts like a pointer:  Provide a common interface for traversing a sequence of elements (without revealing underlying implementation)  Iterator Invalidation - like dangling pointers; it's no longer safe to dereference them and try to access the object they point to  Iterator class must implement: o T & operator*() const; // Dereference operator This study source was downloaded by 100000861003072 from CourseHero.com on 04-24-2023 08:31:50 GMT -05:00

https://www.coursehero.com/file/35022951/EECS-280-Final-Cheat-Sheetdocx/

o Iterator & operator++(); // Prefix increment operator o bool operator==(Iterator rhs) const; // Equality operator o bool operator!=(Iterator rhs) const; // Inequality operator  Traversal by Iterator: List<int>::Iterator end = list.end(); // Equivalent to nullptr for (List<int>::Iterator it = list.begin(); it != end; ++it) // Iterate until the end of the list  friend keyword – allow code in friend class to access the private members of current class o Friendship is given not taken o Syntax: friend class B; // In class A - Gives B access to private variables of A Functors and Function Pointers:  Function Pointer: int (*fn)(int, int) = max; // fn is a pointer to a function that takes two ints and returns an int  Predicate - function that returns either true or false depending on whether its argument has some property  Functor – an object that acts like a function template <typename Iter_type, typename Predicate> // Declares typename for Iterator and Predicate bool any_of(Iter_type begin, Iter_type end, Predicate pred) { for (Iter_type it = begin; it != end; ++it) // Iterates through container { if (pred(*it)) { return true; }} // If any true, return true return false; // If all false, return false } template <typename Iter_t, typename Func_t> // Declares typename for Iterator and Function Func_t for_each(Iter_t begin, Iter_t end, Func_t func) { for (Iter_t it = begin; it != end; ++it) { func(*it); } // Iterate through the container and call function on each item return func; // Return functor }  Comparator - a function that compares two arguments and returns true/false depending on their ordering o It's common to use "less" comparators that return true if the first argument is less than the second argument.  Functors overload the function call operator: void operator()(const T &x) const; Imposter Syndrome:  A concept describing high-achieving individuals who are marked by an inability to internalize their accomplishments and a persistent fear of being exposed as a "fraud".

Recursion:  Auto Keyword – makes compiler automatically deduce variable type  Range-Based For Loop: for (int &item : list) { } // With Auto: for (auto &item : list) { }  Recursion: o Attractive approach for problems with subproblems that are similar or smaller and involve a base case. o Base case – where the recursion stops; typically, solvable without recursion o Linear recursive - if the function makes at most one recursive call each time the function is called o Tail call – if the recursive call is the very last thing in its containing function, so no pending work to do after a tail call o Tail recursive – if ALL the recursive calls made within the function are tail calls, so that no work is done after a recursive call. o Tree recursive - if the function might make more than one recursive call each time the function is called o A function cannot be tree recursive and tail recursive at the same time. One call must happen before the other.

Recursive Data Structures (List, Tree, BST):  List – Either empty, or a datum followed by a sub-list  Tree – Either empty, or a datum with left and right subtrees  Binary Search Tree: A tree is a binary search tree if… o It is empty OR o The left and right subtrees are binary search trees. o All elements in any left subtree are less than the root. o All elements in any right subtree are greater than the root.  Map - a data structure that associates keys with values (can be represented by a BST) o key - what we use to look up or insert an item o value - what is associated with the key  Pair - an STL class template that can be used to represent a pair of objects. o The template parameters determine the type of the first and second objects. o Syntax: std::pair<int, bool> p1; Exceptions:  The exception mechanism introduces an additional control flow path for error handling.  The language is essentially providing us with a structured way to...

1.

Detect Errors: Create and throw an error-like object called an exception, which contains information about what happened.

2.

Propagate the exception outward from a function to its caller until it is handled.

3.

Handle Errors: Catch the exception in a special block of code that handles the error.  Throw statement: o When encountered, regular control flow ceases; the program proceeds outward through each scope until an appropriate catch is found. o Only one object can ever be thrown at a given time.  Catch Statement: o Executes when the corresponding throw is caught; code in the block executes o Catch blocks are tried in order. The first matching block is used. At most one catch block will ever be used. o If no catch block matches, the exception continues outward. Uncaught exception leads to a crash.

Containers of Pointers:  Container holding pointers to objects of the given type; prevents copying of objects  Only one container should "own" the dynamic object and is responsible for cleaning it up.  Destructor - only cleans up memory allocated by the container itself This study source was downloaded by 100000861003072 from CourseHero.com on 04-24-2023 08:31:50 GMT -05:00

https://www.coursehero.com/file/35022951/EECS-280-Final-Cheat-Sheetdocx/

 Containers of pointers don’t have to work with dynamic memory.  A container can only contain one kind of element. However, we can effectively have a container of many different derived types through polymorphism.

Virtual Keyword – allows each class to use its derived version of the function (typically an issue while using polymorphism) // virtual void talk() const; Override Keyword – indicates a function is overriding a virtual function with the same signature in the base class // void talk() const override;

This study source was downloaded by 100000861003072 from CourseHero.com on 04-24-2023 08:31:50 GMT -05:00

https://www.coursehero.com/file/35022951/EECS-280-Final-Cheat-Sheetdocx/ Powered by TCPDF (www.tcpdf.org)