unique_ptr in C++

In C++, unique_ptr is a smart pointer that manages a dynamically allocated object, and it was introduced in C++11. It is defined in the <memory> header file. Here are the key points about unique_ptr:

• Ownership: unique_ptr owns the object it points to. Only one unique_ptr can own an object at a time.
• Move Semantics: Since only one unique_ptr can own an object, it cannot be copied. However, it can be transferred (moved) from one unique_ptr to another using move semantics (std::move).
• Memory Management: unique_ptr automatically deletes the object it points to when it goes out of scope, so there's no need to manually call delete.

Syntax of unique_ptr

unique_ptr<A> ptr1 (new A)

When we write unique_ptr<A> ptr1 (new A), memory is allocated on the heap for an instance of datatype A. ptr1 is initialized and points to newly created A object. Here, ptr1 is the only owner of the newly created object A and it manages this object's lifetime. This means that when ptr1 is reset or goes out of scope, memory is automatically deallocated, and A's object is destroyed.

Since C++14, we can also create a unique pointer using make_unique() function.

unique_ptr<A> ptr1 = make_unique<A>();

Examples of unique_ptr

Create a Unique Ptr

Lets create a structure A and it will have a method named printA to display some text. Then in the main section, let's create a unique pointer that will point to the structure A. So at this point, we have an instance of structure A and p1 holds the pointer to that.

#include <iostream>
#include <memory>
using namespace std;

struct A {
    void printA() {
        cout << "A struct...." << endl;
    }
};

int main() {
    
    unique_ptr<A> p1(new A);
    p1->printA();

    // displays address of the 
    // containing pointer
    cout << p1.get();
    return 0;
}

A struct....
0x3e9dec20

Trying to Copy Object Owned by unique_ptr

#include <iostream>
#include <memory>
using namespace std;

struct A {
    void printA() {
        cout << "A struct...." << endl;
    }
};

int main() {
    
    unique_ptr<A> p1(new A);
    p1->printA();

    // displays address of the 
    // containing pointer
    cout << p1.get() << endl;

    // will give compile time error
    unique_ptr<A> p2 = p1;
    p2->printA();
    return 0;
}

Output

main.cpp: In function ‘int main()’:
main.cpp:18:24: error: use of deleted function ‘std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&)
[with _Tp = A; _Dp = std::default_delete]’
   18 |     unique_ptr<A> p2 = p1;
      |                        ^~
In file included from /usr/include/c++/11/memory:76,
                 from main.cpp:3:
/usr/include/c++/11/bits/unique_ptr.h:468:7: note: declared here
  468 |       unique_ptr(const unique_ptr&) = delete;
      |       ^~~~~~~~~~

The above code will give compile time error as we cannot assign pointer p2 to p1 in case of unique pointers. We have to use the move semantics for such purpose as shown below.

Moving Object Owned by unique_ptr

#include <iostream>
#include <memory>
using namespace std;

struct A {
    void printA() {
        cout << "A struct...." << endl;
    }
};

int main() {
    
    unique_ptr<A> p1(new A);
    p1->printA();
  
    // displays address of the 
    // containing pointer
    cout << p1.get() << endl;

    // now address stored in p1 
    // shpould get copied to p2
    unique_ptr<A> p2 = move(p1);

    p2->printA();
    cout << p1.get() << endl;
    cout << p2.get();
    return 0;
}

A struct....
0x3514c20
A struct....
0
0x3514c20

In the above code, once the address in pointer p1 is copied to pointer p2, the pointer p1's address becomes NULL(0) and the address stored by p2 is now the same as the address stored by p1 showing that the address in p1 has been transferred to the pointer p2 using the move semantics.

When to use unique_ptr?

When ownership of resource is required. When we want single or exclusive ownership of a resource, then we should go for unique pointers. Only one unique pointer can point to one resource. So, one unique pointer cannot be copied to another. Also, it facilitates automatic cleanup when dynamically allocated objects go out of scope and helps preventing memory leaks.