std::unique_ptr

C++ Reference
Language Concepts Utilities library Strings library Containers library Algorithms library Iterators library Numerics library Input/output library Localizations library Regular expressions library (C++11) Atomic operations library (C++11) Thread support library (C++11)
Utilities library
Dynamic memory management
Low level memory management Allocators allocator allocator_traits (C++11) allocator_arg_t (C++11) allocator_arg (C++11) uses_allocator (C++11) scoped_allocator_adaptor (C++11) Uninitialized storage uninitialized_copy uninitialized_copy_n (C++11) uninitialized_fill uninitialized_fill_n raw_storage_iterator get_temporary_buffer return_temporary_buffer Smart pointers unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (deprecated) owner_less (C++11) enable_shared_from_this (C++11) bad_weak_ptr (C++11) default_delete (C++11) Garbage collection support declare_reachable (C++11) undeclare_reachable (C++11) declare_no_pointers (C++11) undeclare_no_pointers (C++11) pointer_safety (C++11) get_pointer_safety (C++11) Miscellaneous pointer_traits (C++11) addressof (C++11) align (C++11) C Library malloc calloc realloc free
std::unique_ptr
Member functions unique_ptr::unique_ptr unique_ptr::~unique_ptr unique_ptr::operator= Modifiers unique_ptr::release unique_ptr::reset unique_ptr::swap Observers unique_ptr::get unique_ptr::get_deleter unique_ptr::operator bool unique_ptr::operator* unique_ptr::operator-> unique_ptr::operator[] Non-member functions operator== operator!= operator< operator> operator<= operator> operator>= std::swap std::hash

Defined in header <memory>
template<     class T,     class Deleter = std::default_delete<T> > class unique_ptr;	(1)	(since C++11)
template <     class T,     class Deleter > class unique_ptr<T[],Deleter>;	(2)	(since C++11)

std::unique_ptr is a smart pointer that retains sole ownership of an object through a pointer. unique_ptr is not copyable or copy-assignable, two instances of unique_ptr cannot manage the same object. A non-const unique_ptr can transfer the ownership of the managed object to another unique_ptr. A const std::unique_ptr cannot be transferred, limiting the lifetime of the managed object to the scope in which the pointer was created. When the unique_ptr is destroyed, it disposes of the object through Deleter.

1) manages the lifetime of a single object, e.g. allocated with new

2) manages the lifetime of an array with a runtime length, e.g. allocated with new[]

Typical uses of std::unique_ptr include

• providing exception safety to classes and functions that handle objects with dynamic lifetime, by guaranteeing deletion on both normal exit and exit through exception.

• passing ownership of uniquely-owned objects with dynamic lifetime into functions

• acquiring ownership of uniquely-owned objects with dynamic lifetime from functions

• as the element type in move-aware containers, such as std::vector, which hold pointers to dynamically-allocated objects, e.g. if polymorphic behavior is desired

Member types

Member type	Definition
pointer	std::remove_reference<D>::type::pointer if that type exists, otherwise T*
element_type	T, the type of the object managed by this unique_ptr
deleter_type	Deleter, the function object or lvalue reference to function or to function object, to be called from the destructor

Member functions

(constructor)	constructs new unique_ptr (public member function)
(destructor)	destructs the managed object if such is present (public member function)
operator=	assigns the unique_ptr (public member function)
Modifiers
release	returns a pointer to the managed object and releases the ownership (public member function)
reset	replaces the managed object (public member function)
swap	swaps the managed objects (public member function)
Observers
get	returns a pointer to the managed object (public member function)
get_deleter	returns the deleter that is used for destruction of the managed object (public member function)
operator bool	checks if there is associated managed object (public member function)
Single-object version, unique_ptr<T>
operator* operator->	dereferences pointer to the managed object (public member function)
Array version, unique_ptr<T[]>
operator[]	provides indexed access to the managed array (public member function)

Non-member functions

operator== operator!= operator< operator<= operator> operator>=	compares with another unique_ptr or with nullptr (function template)
std::swap(std::unique_ptr) (C++11)	specializes the std::swap algorithm (function template)

Helper classes

std::hash<std::unique_ptr> (C++11)	hash support for std::unique_ptr (class template specialization)