Smart Pointers

• We have learned raw pointers
  • This is where you completely manage your dynamic memory.
• Even with solid programming practices, this becomes problematic.
  • Consider this code

  • void Bar() {
         FooT * foo = new FooT;
         foo->SomeMethod();
    } 

  • Bar clearly has a memory leak.
  • What about this? (A step beyond)

  • void Bar2() {
         FooT * foo = new FooT;
         foo->SomeMethod();
    
         delete foo;
    } 

  • What happens if SomeMethod() throws an exception?
• Smart pointers are an implementation of what the course outline calls the "wrapper class".
• Smart pointers are an implementation of "resource acquisition is initialization" (RAII)
  • Constructor acquires, destructor releases.
  • Let the constructor and destructor take care of things.
• Smart pointers are the way to go.
• The big idea
  • The constructor for a smart pointer allocates memory.
  • Copy constructor, assignment operator and others keep track of how many instances are using this pointer.
  • The destructor deallocates this memory when the count goes to 0.
• There are several types of smart pointers.
  • Two are active, unique_ptr, and shared_ptr.
  • There is another that was deprecated in 14 and removed in 17
• unique_ptr is for when you only need one pointer to memory.
  • Think of building a vector class.
  • The unique pointer only allows one pointer to an item.
• In both cases, they pointer manages memory
  • For unique pointers, duplicate pointers to the same memory are not permitted.
  • When the pointer is pointed to something else, the memory is destroyed.
  • Or when the last instance is changed or removed the pointer is destroyed.
  • Think

    DataT * data{nullptr};
    ...
    UniquePointerT & operator =(UniquePointerT & other) {
        if (data != nullptr) {
            delete data;
        }
        data = other.data
        other.data = nullptr;
    }