Unique Pointers

• This is a faster overview.
• 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 an array.  

• Generally, these are constructed with make_unique
  • This is a non-member function.
  • There are several versions of this.

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

• They act like pointers or arrays
  • * and -> are defined for single element types
  • [] is defined for arrays.
• The move function is required to copy one.
• get gets the underlying pointer.
  • Careful here, please don't undo the underlying
• Look at uniqueTest.cpp.
• An application
  • MyVector.h
  • and vectorTest.cpp
  • I have written a basic vector class.
  • Using a unique_ptr as the basis.
  • note the overloading of the [] operator.
    • The const version is for the RHS of an assignment
    • The non- const version is for the LHS of an assignment