Smart Pointers. Some slides from Internet

Transcription

1 Smart Pointers Some slides from Internet 1

2 Part I: Concept Reference: Using C++11 s Smart Pointers, David Kieras, EECS Department, University of Michigan C++ Primer, Stanley B. Lippman, Jesee Lajoie, Barbara E. Moo 2

3 C++11 C++11 (formerly known as C++0x) is a version of the standard of the C++ programming language. It was approved by ISO on 12 August 2011, replacing C++03, superseded by C++14 on 18 August The C++17 specification reached the Draft International Standard stage in March

4 C New language features 1.1 Function return type deduction 1.2 Alternate type deduction on declaration 1.3 Relaxed constexpr restrictions 1.4 Variable templates 1.5 Aggregate member initialization 1.6 Binary literals 1.7 Generic lambdas 1.8 Lambda captures expressions 2 New standard library features 2.1 Shared mutexes and locking 2.2 Heterogeneous lookup in associative containers 2.3 Standard user-defined literals 2.4 Tuple addressing via type 2.5 Smaller library features 4

5 Memory Management One of the major issues in writing C/C++ code is managing dynamically allocated memory Biggest question is how to ensure that allocated memory will be freed when it is no longer in use 5

6 The rule of three If you need to explicitly declare either the destructor, copy constructor or copy assignment operator yourself, you probably need to explicitly declare all three of them. -is-the-rule-of-three 6

7 template <class T> class Wrapper { public: T* operator->() { return &myt; } private: T myt; }; int main() { Wrapper<Thing> wthing; wthing->foo(); // calls Thing::Foo()... } template <class T> class Wrapper { public: T* operator->() { return &myt; } private: T myt; }; int main() { Wrapper<Thing> wthing; wthing->foo(); // calls Thing::Foo()... } template <class T> class Wrapper { public: T* operator->() { return &myt; } private: T myt; }; int main() { Wrapper<Thing> wthing; wthing->foo(); // calls Thing::Foo()... } template Smart->Pointers* <class T> class Wrapper { public: T* operator->() { return &myt; } private: T myt; }; main() { Wrapper<Thing> wthing; wthing->foo(); // calls Thing::Foo()... } template <class T> class Wrapper { public: T* operator->() { return &myt; } private: BY: T GLENN myt; }; int main() WHEELER { Wrapper<Thing> AND MOHAMED wthing; SHAIKH wthing->foo(); // calls Thing::Foo()... } template <class T> class Wrapper { public: T* operator->() { return &myt; } private: T myt; }; int main() { Wrapper<Thing> wthing; wthing->foo(); // calls Thing::Foo()... } template <class T> class Wrapper { public: T* operator->() { return &myt; } private: T myt; }; int main() { Wrapper<Thing> wthing; wthing->foo(); // calls Thing::Foo()... } template <class T> class Wrapper { public: T* operator->() { return &myt; } private: T myt; }; int main() { Wrapper<Thing> wthing; wthing->foo(); 7 // calls Thing::Foo()... }

8 Smart Pointers Introduction What are they? An example of Smart Pointers Benefits of Smart Pointers Conclusion 8

9 Introductions In programming, the use of pointers are the main source of errors (or bugs) when developing code. The main problem found are the occurrences of memory leaks, this is due to the way pointers interact with memory, such as allocation and deallocation, which when performed inefficiently can cause the pointer to hang (or dangle, meaning that the pointer points to a previous removed object). The solution to this dilemma is the use of Smart Pointers. 9

10 What are Smart Pointers? Smart Pointers look the same as normal pointers and utilise the same interfacing operations such as dereferencing (*) and indirection (->) yet carry other functionality. Smart pointers reduce bugs and retain efficiency and control memory management by automated methods. 10

11 Example: String class class String { public: String( char const *str ) { int l = strlen(str); m_data = new char[l]; memcpy(m_data, str, l); } ~String() { delete [] m_data; } private: char* m_data; }; The memory for char* represented by String is owned by the object Class encapsulates details of memory management With careful implementation, this class is memory-tight 11

12 What are Smart Pointers? These automated methods apply to such things as allocation and deallocation of resources in the effort of eliminating memory leaks. template <class T> class auto_ptr { T* ptr; public: explicit auto_ptr(t* p = 0) : ptr(p) {} ~auto_ptr() T& operator*() {delete ptr;} {return *ptr;} T* operator->() {return ptr;} }; 12

13 An Example of Smart Pointers Within the standard C++ library is an example of a really simple smart pointer implementation. This example, auto_ptr, demonstrates memory management and is found within the memory header file. 13

14 An Example of Smart Pointers template <class T> class auto_ptr { T* ptr; public: explicit auto_ptr(t* p = 0) : ptr(p) {} ~auto_ptr() {delete ptr;} T& operator*() {return *ptr;} T* operator->() {return ptr;} }; 14

15 An Example of Smart Pointers Therefore instead of writing Therefore user writes void foo() { MyClass* p(new MyClass); p->dosomething(); delete p; } void foo() { auto_ptr<myclass> p(new MyClass); p->dosomething(); } 15

16 An Example of Smart Pointers Here is an sample of code which illustrates the situation of a dangling pointer MyClass* p(new MyClass); MyClass* q = p; delete p; p->dosomething(); p = NULL; q->dosomething(); // Watch out! p is now dangling! // p is no longer dangling // Ouch! q is still dangling! 16

17 An Example of Smart Pointers For auto_ptr, this is solved by setting its pointer to NULL when it is copied: template <class T> auto_ptr<t>& auto_ptr<t>::operator=(auto_ptr<t>& rhs) { if (this!= &rhs) { } delete ptr; ptr = rhs.ptr; rhs.ptr = NULL; return *this; } 17

18 Benefits of Smart Pointers The main, obvious benefits of using smart pointers as stated before are the increased efficiency of memory management over normal pointers. This efficiency consists of three main abilities of smart pointers which are, automated initialisation, handling of dangling pointers and automatic clean up. 18

19 Benefits of Smart Pointers (2) Automated initialisation removes the need for setting the smart pointer to NULL, which therefore removes the need for that code to be written, which is similar to the benefits of automatic clean up in a way. The automatic clean up feature means that smart pointers automatically clean up, reduces the amount of code needed to be written, and in turn reducing the possibility of bugs. 19

20 Benefits of Smart Pointers (3) Major benefit of the smart pointer is its handling of dangling pointers. These so called dangling pointers are a very common problem and are caused by the pointer pointing to an object that is already deleted. Another problem faced by software programmers is the possibility of an exception error occurring in the program. 20

21 Benefits of Smart Pointers (4) If an exception occurs within a pointer this means that the remaining code after it will not get executed and in turn the pointer will not get deleted with the potential of memory leaks occurring. However the use of a smart pointer will remove this threat due to the automatic clean up of the pointer because the pointer will be cleaned up whenever it gets out of scope, whether it was during the normal path of execution or during an exception. This solution is possible to write for normal pointers; however it is much simpler to implement using smart pointers 21

22 Conclusion As previously stated smart pointers are great for efficient memory management. They can be used to make more efficient use of available memory and to shorten allocation and deallocation time and prevents bugs caused by standard pointers. Auto_ptr: the simplest smart pointer to use. For situations when there are no special requirements. 22

23 Part II: C++ 11 Smart Pointer 23

24 C++ Memory Management Idioms Idioms are reusable design techniques in a language We ll look at 4 important ones in C++ Copy constructor trick for assignment Ensures release of existing resource and acquisition of the new resource both succeed or fail together RAII (a.k.a. Guard) ties dynamic resources to other (esp. automatic) scopes Reference counting ties dynamic lifetime to a group of references Copy-on-write allows more efficient management of multiple aliasing 24

25 Copy Constructor Trick for Assignment Cleanup/assignment succeed or fail together class Array { public: Array(unsigned int) ; Array(const Array &); // assume copy constructor makes a deep copy ~Array(); Array & operator=(const Array &a); private: }; int * ints_; size_t size_; Array & Array::operator=(const Array &a) { if (&a!= this) { } Array temp(a); std::swap(temp.ints_, ints_); std::swap(temp.size_, size_); return *this; } 25

26 C++11 Smart Pointers C++11 deprecates an older smart pointer template auto_ptr : can guard dynamically allocated memory and pass ownership around, but doesn t work with the STL containers and has other limitations C++11 provides 3 new smart pointer templates instead shared_ptr : a general purpose reference counted guard for dynamic memory (we ll mostly use this one in this course) weak_ptr : gives access to a resource that is guarded by a shared_ptr without increasing reference count (can be used to prevent memory leaks due to circular references) unique_ptr : a more complex but potentially very efficient way to transfer ownership of dynamic memory safely (implements C++11 move semantics ) 26

27 Resource Acquisition Is Initialization (RAII) Also referred to as the Guard Idiom However, the term RAII is more widely used in C++ Relies on the fact that in C++ a stack object s destructor is called when stack frame pops Idea: we can use a stack object to hold the ownership of a heap object, or any other resource that requires explicit clean up Initialize stack object when the resource is allocated De-allocate resource in the stack object s destructor 27

28 RAII Example: Guarding Newly Allocated Object shared_ptr<foo> createandinit() { Foo *f = new Foo; shared_ptr<foo> p(f); init(f);// may throw exception return p; } int run () { try { shared_ptr<foo> spf = createandinit(); cout << *spf is << *spf; } catch (...) { return -1 } return 0; } RAII idiom example via shared_ptr class template #include <memory> using namespace std; shared_ptr<x> assumes and maintains ownership of aliased X Can access the aliased X through it (*spf) shared_ptr destructor calls delete on the pointer to the owned X when it s safe to do so (per reference counting idiom discussed next) Combines well with other memory idioms 28

29 reference reference reference Introduction to Reference Counting Resource counter == 3 Basic Problem Resource sharing is often more efficient than copying But it s hard to tell when all are done using a resource Must avoid early deletion Must avoid leaks Solution Approach Share both the resource and also a counter Each new reference increments the counter When a reference is done, it decrements the counter When count drops to zero, delete resource and counter last one out shuts off the lights 29

30 Reference Counting Example: Sharing an Object shared_ptr<foo> createandinit() { Foo *f = new Foo; shared_ptr<foo> p(f); init(f);// may throw exception return p; } int run () { try { shared_ptr<foo> spf = createandinit(); shared_ptr<foo> spf2 = spf; // object destroyed after // both spf and spf2 go away } catch (...) { return -1 } return 0; } RAII idiom example via shared_ptr class template #include <memory> using namespace std; shared_ptr<x> assumes ownership of aliased X shared_ptr<x> copy constructor increases count, and its destructor decreases count shared_ptr destructor calls delete on the pointer to the owned X when count drops to 0 30

31 Introduction to Copy on Write (Clone on Write) write() reference Resource 2 counter == 1 Basic Problem Reference counting enables safe and efficient sharing But what if modifications are made to the resource? May want logically separate copies of resource reference reference Resource counter == 2 Solution Start with reference counting Writer checks for count > 1 Copies reference & counter Updates both counters Performs the write Readers all share a copy, each writer can get its own 31

32 Reference Counting Suppose String has operator[] Consider the following code String a = foo bar ; String b = a; String c = a; c[2] = l ; What does this code do? 32

33 Reference Counting After we modify c, it is no longer identical to a and b We can no longer save memory by storing all three strings in one place Solution Clone on Write make a copy of an object when it is modified 33

34 Implementing operator[] in String Read-only access: char const& operator[](int i) const { return m_ptr->m_data[i]; } Read/Write access: char & operator[](int i) { } if( m_ptr->m_rc > 1 ) { // make a new copy of the string } m_ptr->m_rc--; m_ptr = new StringValue( *m_ptr ); return m_ptr->m_data[i]; 34

35 Clone on Write Perform the copy operation only when new copy is needed This is an instance of lazy evaluation How can we perform this in a generic RCPointer? 35

36 Template Clone on Write Distinguish between read only access: T const& RCPointer<T>::operator*() const; T const* RCPointer<T>::operator->() const; and read/write access T& RCPointer<T>::operator*(); T* RCPointer<T>::operator->(); In these operations we perform copy 36

37 Reference counting and cycles Reference counting could have been used as an automatic garbage collection in C++. Problem: Data structures can include cycles. In this case the pointers will never be deleted. If all these pointers were reference counted, then no memory would be freed 37

38 Weak_ptr "weak" smart pointers: these only "observe" an object but do not influence its lifetime. A ring of objects can point to each other with weak_ptrs, which point to the managed object but do not keep it in existence. the "observing" relations are shown by the dotted arrows. 38

39 How they works 39

40 How shared_ptr & weak_ptr works Whenever a shared_ptr is destroyed, or reassigned to point to a different object, the shared_ptr destructor or assignment operator decrements the shared count. Similarly, destroying or reassigning a weak_ptr will decrement the weak count. when the shared count reaches zero, the shared_ptr destructor deletes the managed object and sets the pointer to 0. If the weak count is also zero, then the manager object is deleted also, and nothing remains. 40

41 Summary: Memory Management Tips Know what goes where in memory Understand mechanics of stack and heap allocation Watch for simple (and complex) lifetime errors Think about shallow copy vs. deep copy (problems and performance trade-offs) Master useful idioms for C++ memory management Learn how they work Understand when to apply them Look for ways to apply them in the labs and beyond C++11 smart pointers (especially shared_ptr) very helpful 41

42 The End n Using C++11 s Smart Pointers, David Kieras, EECS Department, University of Michigan n C++ Primer, Stanley B. Lippman, Jesee Lajoie, Barbara E. Moo 42