Smart Pointers

• Read your book starting on page 234.
• We have learned raw pointers
  • This is where you completely manage your dynamic memory.
• Even with solid programming practices, this becomes problematic.
• Both of my last demo programs had memory problems.
  • The demo didn't free all memory when a player with spell went out of lifetime.
    • this is a reasonably major problem in a long term game and would probably have crashed it.
  • The game didn't free the team when it ended.
    • This is really less of a problem, but not good programming practice.
    • Fixing this was a minor pain
      • When I added a loop to destroy the instances, the compiler complained that my base case did not have a destructor.
      • When I added this, my game crashed hard.
      • I needed to add destructors to all of my instances as well.
• Both of these could have been avoided with smart pointers.
• But there are other problems as well.
  • Consider this code (What I had essentially)

  • 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;
    }