Uniqueptr

Uniqueptr, typically referring to the C++ standard library type std::unique_ptr, is a smart pointer that exclusively owns a dynamically allocated object or array. It provides automatic lifetime management, ensuring that the managed resource is released when the unique_ptr goes out of scope.

Ownership and semantics

Uniqueptr embodies exclusive ownership: it is move-only and cannot be copied. Ownership can be transferred via move construction or move assignment, leaving the source in a null state. This design enforces clear ownership boundaries and helps prevent double frees and resource leaks. A unique_ptr can be reset to release the current object and optionally take ownership of a new one.

Construction and usage

A unique_ptr supports dereferencing and member access like a raw pointer, with operator* and operator->. It also offers get() to obtain the raw pointer, release() to relinquish ownership without deleting the object, and reset() to replace the managed object. For safe creation, make_unique (since C++14) is preferred over direct new usage, reducing the likelihood of leaks or exceptions during construction.

Deleters and arrays

Unique_ptr is a template std::unique_ptr<T, D> where D is a deleter type (defaulting to std::default_delete<T>). This allows custom deletion logic, such as freeing resources other than memory. There is a specialization for arrays, std::unique_ptr<T[]>, which uses delete[] for array elements. Proper deleter choice is essential when managing non-raw resources.

Relation to other pointers and uses

Unique_ptr provides exclusive ownership with no reference counting, differing from std::shared_ptr, which enables shared ownership. It is a fundamental RAII tool in modern C++ for automatic, deterministic resource management. It is defined in the memory header and has been part of the language since C++11, with make_unique becoming common in C++14 and later.