Unique Pointers

• This is a faster overview.
  • We are running out of time.
  • You will probably not implement anything with these. (but you should)
• They are covered in chapter 7
  • Also a reference to unique_ptr
  • And make_unique
• Probably implemented something like this

  // I have not implemented/tested this code. 
  // There are most likely errors.
  // This is for conversation.
  
  template <typename T>
  class UniquePointerT {
    public:
      UniquePointerT(): data{new T} { }
      UniquePointerT(const UniquePointerT & other) {
          // copy it allocating new data.
      }
      UniquePointerT & operator =(const UniquePointerT & other)=delete;
      ~UniquePointerT() {
          delete data;
      }
    private:
        T * data;
  } 

  • Notice, when this goes out of lifetime, the pointer is destroyed.
  • Since there is no copy, we can't have two variables pointing to the same memory, no dangling pointers, no double delete.
  • There is no need to delete anything, the class handles this.
• You need to include memory
• The templated class unique_ptr

  unique_ptr<type> var; // a pointer to a single item
  unique_ptr<type[]> var; // a pointer to a and array.  

• Generally, these are constructed with make_unique

data = make_unique<int>();
data1 = make_unique<int>(7);
data2 = make_unique<int[]>(size);