Rule of Three and std::unique_ptr

The Rule of Three in C++ is a guideline that states if a class needs to define one of the following special member functions, it likely needs to define all three:

1. Destructor
2. Copy Constructor
3. Copy Assignment Operator

The Rule of Three is traditionally concerned with managing resource ownership and cleanup. However, when using std::unique_ptr, the Rule of Three changes slightly:

With std::unique_ptr, you don't need to define a custom destructor unless you need to perform additional cleanup. std::unique_ptr automatically handles the deletion of the managed resource when the object is destroyed.

1class MyClass {
2 public:
3  std::unique_ptr<int> ptr;
4  MyClass() : ptr(std::make_unique<int>(42)) {}
5  // Destructor is automatically generated
6  // and manages resource cleanup
7};

std::unique_ptr is not copyable. It enforces unique ownership, so copying is not allowed. If you attempt to copy a std::unique_ptr, it will result in a compile-time error.

1MyClass obj1;
2
3// Error: std::unique_ptr cannot be copied
4MyClass obj2 = obj1;

Similar to the copy constructor, the copy assignment operator is deleted for std::unique_ptr. You can only move std::unique_ptr, which transfers ownership.

1MyClass obj1;
2MyClass obj2;
3
4// Correct: moves ownership from obj1 to obj2
5obj2 = std::move(obj1);

Since std::unique_ptr does not allow copying, it relies on move semantics:

Move Constructor: Transfers ownership from one std::unique_ptr to another.

1std::unique_ptr<int> ptr1{
2  std::make_unique<int>(42)};
3  
4// Ownership transferred to ptr2
5std::unique_ptr<int> ptr2{
6  std::move(ptr1)};

Move Assignment Operator: Assigns ownership from one std::unique_ptr to another.

1std::unique_ptr<int> ptr1{
2  std::make_unique<int>(42)};
3std::unique_ptr<int> ptr2;
4
5// Ownership transferred to ptr2
6ptr2 = std::move(ptr1);

When using std::unique_ptr, the Rule of Three does not apply in the traditional sense since std::unique_ptr is non-copyable and manages its own resource cleanup.

Instead, focus on understanding and using move semantics with std::unique_ptr for efficient resource management.