What are the benefits and drawbacks of using unique_ptr in C++?

Such article is very straight forward and to the point; it provides the meaning and use cases of smart pointers over the regularly used raw pointers.

Smart pointers are essential tools in modern C++ programming for managing dynamic memory efficiently and safely. Unlike raw pointers, they offer built-in features like automatic memory management and exception safety. These pointers help prevent common pitfalls such as memory leaks and dangling pointers by handling memory allocation and deallocation transparently. The two primary types, unique_ptr and shared_ptr, serve distinct purposes: unique_ptr ensures exclusive ownership of an object, while shared_ptr allows multiple pointers to refer to the same object, managing its lifetime through reference counting. Mastering smart pointers is crucial for writing robust and reliable C++ code.

Unique_ptr offers automatic memory management, preventing leaks and dangling pointers. It enforces exclusive ownership, simplifying resource management and improving code readability. Though it lacks copyability, limiting its use in scenarios requiring shared ownership. Consider shared_ptr for those cases.

Automatic Cleanup: When the last unique_ptr that owns an object goes out of scope or is reset, the object is automatically deleted. This ensures proper memory management without the risk of memory leaks. Creation: To create a unique_ptr, you can use the std::make_unique function in C++14 and later, or use the new operator with the constructor of the object it will manage. Using unique_ptr provides strong guarantees about the lifetime of dynamically allocated objects, helps prevent common programming errors related to memory management, and supports efficient resource handling in C++ applications. However, its exclusive ownership model may require careful consideration in scenarios where shared ownership is needed.

Assigning one unique pointer to another by using the assignment operator (=) is not possible. In the same fashion, it is not possible to copy a unique pointer since the copy constructor in a unique pointer is deleted explicitly.

Think of using a unique_pointer when we want exclusive ownership of the resource created on the heap. Think of using raw pointer when we need pointer that are non-owning

strong owner ship of the data as it can only be accessed through one place(pointer) so data can never be changed through another pointer accidentally.

Two unique pointers may end up owning the same resource if the address of the resource which is already created is passed to the constructor of unique pointers. Resource * raw_ptr = new Resource(); std::unique_ptr<Resource> owner1(raw_ptr); std::unique_ptr<Resource> owner2(raw_ptr); This will result in an attempt to delete the same Resource twice; first when owner2 goes out of scope and the second when owner1 goes out of scope.(undefined behaviour)

pointer cannot be copied thus pass by value feature is gone unlike shared_ptr where the use count will increase and decrease by one for the lifetime of a function call.

Both shared_ptr and unique_ptr are designed to be passed by value (with the obvious movability requirement for the unique pointer). Neither should make you worried about the overhead since their power is truly astounding, but if you have a choice, prefer unique_ptr (movable), and only use shared_ptr (movable & copyable) if you really need shared ownership.