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

How the Rule of Three Applies

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:

Destructor

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

Copy Constructor

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;

Copy Assignment Operator

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);

Move Semantics

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);

Conclusion

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.