Smart Pointers, deleted functions, and 2-3 trees

Transcription

1 Smart Pointers, deleted functions, and 2-3 trees

2 But first Any questions about your current homework assignment? Due Thursday night by 11:59pm Make-up oral exam: I will have a sign-up sheet on Thursday It will take around minutes I will ask you questions about your code, why you implemented things they way you did, and how some changes would affect the program You will have your program code available, with comments Do not over-comment your code I will remove overly excessive comments

3 heapsort function For sorter.h, you should NOT have a class named sorter Instead, you should have something similar to the following:

4 #ifndef SORTER_H #define SORTER_H #include // stuff template <class T> T* heapsort(t* array, int num) { // code code code } #endif

5 T pop() { assert(size()!= 0);

6 T pop() { if (size() == 0) { throw HeapException( Can t pop when empty ); }

7 T pop() { GZassert(size()!= 0, Can t pop from empty, HeapException);

8

9 Garbage collection Some/many programming languages have a built-in garbage collector that automagically calls delete on data that is no longer being used C# Java Python Go Javascript Ruby Lisp

10 Garbage collection Garbage collection means that objects that are no longer referred to are automatically cleaned up Most of this can be accomplished by reference counting "Dumb" pointers just keep track of what they point to "Smart" pointers keep track of what they point to and how many other things point to what they're pointing to When the count reaches zero, we know we can delete the object and free the memory

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30 1 1 1

31 1 1 1

32 Reference counting usage Reference counting is used in a ton of different places, either alone or as part of a larger garbage collection system Programming languages: C++, Python, Objective-C/Swift, GTK/GObject Unix-style filesystems (Linux, Mac) Reference counting by itself has one weakness:

33

34

35

36

37 Reference counting in C++ C++ comes with the class shared_ptr in the header <memory> You can (but should never) initialize a shared_ptr with an arbitrary pointer Every time you create a shared_ptr from a pointer, you are creating a new reference count for that pointer To avoid this problem, C++ also provides a function named make_shared All of these are templated, so let's look at an example...

38 struct Node { int value; Node *next; }; int stuff() { Node *head = new Node; Node *another = new Node; head->next = another; // stuff } return 0;

39 struct Node { int value; Node *next; }; int stuff() { Node *head = new Node; Node *another = new Node; head->next = another; // stuff } Node *node = head; while (node) { Node *tmp = node; node = node->next; delete tmp; } return 0;

40 struct Node { int value; shared_ptr<node> next; };

41 int stuff() { shared_ptr<node> head = make_shared<node>(); shared_ptr<node> another = make_shared<node>(); head->next = another; // stuff } return 0; int stuff() { Node *head = new Node; Node *another = new Node; head->next = another; // stuff } Node *node = head; while (node) { Node *tmp = node; node = node->next; delete tmp; } return 0;

42 int stuff() { auto head = make_shared<node>(); auto another = make_shared<node>(); head->next = another; // stuff } return 0; int stuff() { Node *head = new Node; Node *another = new Node; head->next = another; // stuff } Node *node = head; while (node) { Node *tmp = node; node = node->next; delete tmp; } return 0;

43 template <class T> struct Node { Node<T>* left; Node<T>* right; T value; }; template <class T> class Tree { private: Node<T> *root; public: //etc... }; bool exists(t val) { Node<T> *node = root; while (node) { if (node->value == val) { return true; } if (val < node->value) { node = node->left; } else { node = node->right; } } return false; }

44 template <class T> struct Node { shared_ptr<node<t>> left; shared_ptr<node<t>> right; T value; }; template <class T> class Tree { private: Node<T> *root; public: //etc... }; bool exists(t val) { Node<T> *node = root; while (node) { if (node->value == val) { return true; } if (val < node->value) { node = node->left; } else { node = node->right; } } return false; }

45 template <class T> struct Node { shared_ptr<node<t>> left; shared_ptr<node<t>> right; T value; }; template <class T> class Tree { private: shared_ptr<node<t>> root; public: //etc... }; bool exists(t val) { Node<T> *node = root; while (node) { if (node->value == val) { return true; } if (val < node->value) { node = node->left; } else { node = node->right; } } return false; }

46 template <class T> struct Node { shared_ptr<node<t>> left; shared_ptr<node<t>> right; T value; }; template <class T> class Tree { private: shared_ptr<node<t>> root; public: //etc... }; bool exists(t val) { auto node = root; while (node) { if (node->value == val) { return true; } if (val < node->value) { node = node->left; } else { node = node->right; } } return false; }

47 public: ~BST() { destructorhelper(root); } private: void destructorhelper(node<t>* node) { if (!node) return; destructorhelper(node->left); destructorhelper(node->right); delete node; }

48

49 class Asdf { public: Asdf(string s) { str = s; } void print() { cout << str << endl; } private: string str; }; int main() { auto asdf = make_shared<asdf>(); }

50

51 In file included from test.cpp:1: In file included from /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/iostream:38: In file included from /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/ios:216: In file included from /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/ locale:15: In file included from /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/string:439: In file included from /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/algorithm:628: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/memory:2142:49: error: no matching constructor for initialization of 'Asdf' : _T1(_VSTD::forward<_T1_param>( t1)), second_() {} ^ TONS OF LINES REMOVED test.cpp:21:17: note: in instantiation of function template specialization 'std:: 1::make_shared<Asdf>' requested here auto asdf = make_shared<asdf>();

52 In file included from /usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/memory:83, from test.cpp:2: /usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/shared_ptr.h: In constructor std::_sp_counted_ptr_inplace<_tp, _Alloc, _Lp>::_Sp_counted_ptr_inplace(_Alloc) [with _Tp = Asdf, _Alloc = std::allocator<asdf>, gnu_cxx::_lock_policy _Lp = ( gnu_cxx::_lock_policy)2u] : /usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/shared_ptr.h:291: instantiated from std:: shared_count<_lp>:: shared_count(std::_sp_make_shared_tag, _Tp*, _Alloc, _Args&&...) [with _Tp = Asdf, _Alloc = std::allocator<asdf>, _Args =, gnu_cxx::_lock_policy _Lp = ( gnu_cxx::_lock_policy)2u] /usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/shared_ptr.h:857: instantiated from std:: shared_ptr<_tp, _Lp>:: shared_ptr(std::_sp_make_shared_tag, _Alloc, _Args&&...) [with _Alloc = std::allocator<asdf>, _Args =, _Tp = Asdf, gnu_cxx::_lock_policy _Lp = ( gnu_cxx::_lock_policy)2u] /usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/shared_ptr.h:1340: instantiated from std::shared_ptr<_tp>::shared_ptr(std::_sp_make_shared_tag, _Alloc, _Args&&...) [with _Alloc = std::allocator<asdf>, _Args =, _Tp = Asdf] /usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/shared_ptr.h:1569: instantiated from std::shared_ptr<_tp1> std::allocate_shared(_alloc, _Args&&...) [with _Tp = Asdf, _Alloc = std::allocator<asdf>, _Args = ] /usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/shared_ptr.h:1584: instantiated from std::shared_ptr<_tp1> std::make_shared(_args&&...) [with _Tp = Asdf, _Args = ] test.cpp:22: instantiated from here /usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/bits/shared_ptr.h:175: error: no matching function for call to Asdf::Asdf() test.cpp:9: note: candidates are: Asdf::Asdf(std::string) test.cpp:7: note: Asdf::Asdf(const Asdf&)

53 class Asdf { public: Asdf(string s) { str = s; } void print() { cout << str << endl; } private: string str; }; int main() { auto asdf = make_shared<asdf>("test"); }

54 Smart pointers and ada Unfortunately, ada's version of C++ is too old to reliably work in this class When using smart pointers, you can try compiling your code using the following command: g++ -std=c++0x -Wall -g filename.cpp If you were using ada as your main development environment, talk to me and I can help you migrate to something that works better

55 Smart pointers and the rule of three Smart pointers won't save us from the issues requiring the rule of three Smart pointers will prevent us from crashing We would still end up with multiple objects sharing the same memory Sometimes, we don't care about people being able to copy an object

56 template <class T> class BST { public: BST() { } BST(const BST<T>& other) = delete; BST<T>& operator=(const BST<T> &other) = delete; };

57 template <class T> class BST { public: BST() { } BST(const BST<T>& other) = delete; BST<T>& operator=(const BST<T> &other) = delete; }; int main() { BST<int> b; BST<int> c = b; // calls copy constructor }

58 test.cpp: In function int main() : test.cpp:16: error: deleted function BST<T>::BST(const BST<T>&) [with T = int] test.cpp:24: error: used here test.cpp:24:14: error: call to deleted constructor of 'BST<int>' BST<int> c = b; ^ ~ test.cpp:16:5: note: 'BST' has been explicitly marked deleted here BST(const BST<T>& other) = delete; ^ 1 error generated.

59 Going forward in this class You will still need to abide by the rule of three

60 Going forward in this class You will still need to abide by the rule of three Your code should not leak resources, including memory. This means that if a class allocates memory, it MUST have a destructor, and should either delete or implement the assignment operator and copy constructor.

61 Going forward in this class You will still need to abide by the rule of three You should never use new to allocate memory for a single element. Instead, use make_shared<whatevertype>() It's still okay (for now) if you need to allocate an array You should never have a "raw" pointer to a single element, instead you should use shared_ptr<whatevertype>

62 Self-balancing search trees With a simple binary search tree, we can create a situation where we end up with a lopsided tree that looks like a linked list Many search tree operations are O(height) Smarter versions of a search tree can guarantee that the tree is balanced to some degree This can guarantee O(log n) insertion, deletion, and search, regardless of the order of insertion

63 2-3 trees A 2-3 tree is a special type of B-Tree A 2-3 tree contains nodes of two types: 2-nodes are binary search tree nodes 1 data value, 2 children 3-nodes are larger 2 data values, 3 children

64 2-Node V e < V e > V

65 3-Node S L e < S S < e < L e > L

66 template <class T> struct TwoThreeNode { T small; T large; }; shared_ptr<twothreenode<t>> left; shared_ptr<twothreenode<t>> mid; shared_ptr<twothreenode<t>> right;

67 Searching in a 2-3 tree Based on how we search in a binary search tree, how could we search a 2-3 tree to see if an item exists?

68 Searching a 2-3 tree Current node = root While current node is not null: Is this a 2 node? Is the value equal to our value? return true Is the value less than our value? current node = current node->left else current node = current node->right

69 Searching a 2-3 tree // this is a 3 node Is value equal to our smaller value? return true Is value equal to our larger value? return true Is value less than our smaller value? current node = current node->left else, is value less than our larger value? current node = current node->mid else current node = current node->right

70 Adding elements to a 2-3 tree To add elements to a 2-3 tree, let's first talk about what a 4-node is...

71 4-Node S M L e < S S < e < M M < e < L e > L

72 Adding elements to a 2-3 tree We will never create a 4-node directly However, the insertion algorithm is simpler if we think of "temporary" 4-nodes as existing

73 Adding elements to a 2-3 tree Step 1: Find the leaf node where the item to be added should go Step 2: Add the item into the leaf node If leaf node is a 2-node: convert into a 3-node If leaf node is a 3-node: convert to a 4-node, then move the middle element into the parent, carrying the side nodes as children Continue this 4-node removing process until no more 4-nodes exist

74

75 add

76 add

77

78 add

79

80

81

82

83

84 add

85

86 add

87

88

89

90

91

92

93

94

95

96

97 Quiz on Thursday On Thursday, you will have a quiz asking you to perform "add" operations on a number of different 2-3 trees You can generate a series of numbers to add using the following python code (either in a script or interactive): import random random.sample(range(100), 15)