| CARVIEW |
Select Language
HTTP/1.1 301 Moved Permanently
Server: nginx
Date: Sat, 19 Jul 2025 19:17:57 GMT
Content-Type: text/html; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
Location: /reference/memory/unique_ptr/
HTTP/1.1 200 OK
Server: nginx
Date: Sat, 19 Jul 2025 19:17:58 GMT
Content-Type: text/html; charset=utf-8
Transfer-Encoding: chunked
Connection: keep-alive
ETag: W/"9e79-44ruvAEf3xx55C/210UCNvXxa4Y"
Content-Encoding: gzip
Manages the storage of a pointer, providing a limited garbage-collection facility, with little to no overhead over built-in pointers (depending on the deleter used).
These objects have the ability of taking ownership of a pointer: once they take ownership they manage the pointed object by becoming responsible for its deletion at some point.
unique_ptr objects automatically delete the object they manage (using a deleter) as soon as they themselves are destroyed, or as soon as their value changes either by an assignment operation or by an explicit call to unique_ptr::reset.
unique_ptr objects own their pointer uniquely: no other facility shall take care of deleting the object, and thus no other managed pointer should point to its managed object, since as soon as they have to, unique_ptr objects delete their managed object without taking into account whether other pointers still point to the same object or not, and thus leaving any other pointers that point there as pointing to an invalid location.
A unique_ptr object has two components:
unique_ptr objects replicate a limited pointer functionality by providing access to its managed object through operators * and -> (for individual objects), or operator [] (for array objects). For safety reasons, they do not support pointer arithmetics, and only support move assignment (disabling copy assignments).
Exclusive for non-specialized version (single objects):
Exclusive for the version specialized for arrays with runtime length:
Reference
C library:
- <cassert> (assert.h)
- <cctype> (ctype.h)
- <cerrno> (errno.h)
-
<cfenv> (fenv.h)C++11
- <cfloat> (float.h)
-
<cinttypes> (inttypes.h)C++11
- <ciso646> (iso646.h)
- <climits> (limits.h)
- <clocale> (locale.h)
- <cmath> (math.h)
- <csetjmp> (setjmp.h)
- <csignal> (signal.h)
- <cstdarg> (stdarg.h)
-
<cstdbool> (stdbool.h)C++11
- <cstddef> (stddef.h)
-
<cstdint> (stdint.h)C++11
- <cstdio> (stdio.h)
- <cstdlib> (stdlib.h)
- <cstring> (string.h)
-
<ctgmath> (tgmath.h)C++11
- <ctime> (time.h)
-
<cuchar> (uchar.h)C++11
- <cwchar> (wchar.h)
- <cwctype> (wctype.h)
Containers:
-
<array>C++11
- <deque>
-
<forward_list>C++11
- <list>
- <map>
- <queue>
- <set>
- <stack>
-
<unordered_map>C++11
-
<unordered_set>C++11
- <vector>
-
Input/Output:
Multi-threading:
-
<atomic>C++11
-
<condition_variable>C++11
-
<future>C++11
-
<mutex>C++11
-
<thread>C++11
-
Other:
- <algorithm>
- <bitset>
-
<chrono>C++11
-
<codecvt>C++11
- <complex>
- <exception>
- <functional>
-
<initializer_list>C++11
- <iterator>
- <limits>
- <locale>
- <memory>
- <new>
- <numeric>
-
<random>C++11
-
<ratio>C++11
-
<regex>C++11
- <stdexcept>
- <string>
-
<system_error>C++11
-
<tuple>C++11
-
<type_traits>C++11
-
<typeindex>C++11
- <typeinfo>
- <utility>
- <valarray>
<memory>
classes
- allocator
-
allocator_arg_tC++11
-
allocator_traitsC++11
- auto_ptr
- auto_ptr_ref
-
bad_weak_ptrC++11
-
default_deleteC++11
-
enable_shared_from_thisC++11
-
owner_lessC++11
-
pointer_traitsC++11
- raw_storage_iterator
-
shared_ptrC++11
-
unique_ptrC++11
-
uses_allocatorC++11
-
weak_ptrC++11
enum classes
-
pointer_safetyC++11
-
functions
-
addressofC++11
-
alignC++11
-
allocate_sharedC++11
-
const_pointer_castC++11
-
declare_no_pointersC++11
-
declare_reachableC++11
-
dynamic_pointer_castC++11
-
get_deleterC++11
-
get_pointer_safetyC++11
- get_temporary_buffer
-
make_sharedC++11
- return_temporary_buffer
-
static_pointer_castC++11
-
undeclare_no_pointersC++11
-
undeclare_reachableC++11
- uninitialized_copy
-
uninitialized_copy_nC++11
- uninitialized_fill
- uninitialized_fill_n
-
objects
-
allocator_argC++11
-
unique_ptr
-
unique_ptr::~unique_ptrC++11
-
unique_ptr::unique_ptrC++11
member functions
-
unique_ptr::getC++11
-
unique_ptr::get_deleterC++11
-
unique_ptr::operator boolC++11
-
unique_ptr::operator->C++11
-
unique_ptr::operator[]C++11
-
unique_ptr::operator*C++11
-
unique_ptr::operator=C++11
-
unique_ptr::releaseC++11
-
unique_ptr::resetC++11
-
unique_ptr::swapC++11
-
non-member overloads
-
relational operators (unique_ptr)C++11
-
swap (unique_ptr)C++11
-
class template
<memory>
std::unique_ptr
| non-specialized | template <class T, class D = default_delete<T>> class unique_ptr; |
|---|---|
| array specialization | template <class T, class D> class unique_ptr<T[],D>; |
Unique pointer
These objects have the ability of taking ownership of a pointer: once they take ownership they manage the pointed object by becoming responsible for its deletion at some point.
unique_ptr objects automatically delete the object they manage (using a deleter) as soon as they themselves are destroyed, or as soon as their value changes either by an assignment operation or by an explicit call to unique_ptr::reset.
unique_ptr objects own their pointer uniquely: no other facility shall take care of deleting the object, and thus no other managed pointer should point to its managed object, since as soon as they have to, unique_ptr objects delete their managed object without taking into account whether other pointers still point to the same object or not, and thus leaving any other pointers that point there as pointing to an invalid location.
A unique_ptr object has two components:
- a stored pointer: the pointer to the object it manages. This is set on construction, can be altered by an assignment operation or by calling member reset, and can be individually accessed for reading using members get or release.
- a stored deleter: a callable object that takes an argument of the same type as the stored pointer and is called to delete the managed object. It is set on construction, can be altered by an assignment operation, and can be individually accessed using member get_deleter.
unique_ptr objects replicate a limited pointer functionality by providing access to its managed object through operators * and -> (for individual objects), or operator [] (for array objects). For safety reasons, they do not support pointer arithmetics, and only support move assignment (disabling copy assignments).
Template parameters
- T
- The type of the managed object, aliased as member type element_type.
- D
- Type of the callable object used as deleter, aliased as member type deleter_type.
By default, this is default_delete, which is a stateless functor that simply uses the global delete for the operation, with class causing no additional overhead overall over a built-in pointer.
Member types
The following aliases are member types of unique_ptr.| member type | definition | notes |
|---|---|---|
| element_type | first template parameter (T) | The type of the managed object |
| deleter_type | second template parameter (D) | The type of the stored deleter. Defaults to default_delete<T> |
| pointer | remove_reference<D>::type::pointer, if this type exists T*, otherwise | The pointer type |
Member functions
- (constructor)
- Construct unique_ptr (public member function)
- (destructor)
- Destroy unique_ptr (public member function)
- operator=
- unique_ptr assignment (public member function)
- get
- Get pointer (public member function)
- get_deleter
- Get stored deleter (public member function)
- operator bool
- Check if not empty (public member function)
- release
- Release pointer (public member function)
- reset
- Reset pointer (public member function)
- swap
- Swap content (public member function)
Exclusive for non-specialized version (single objects):
- operator*
- Dereference object (public member function)
- operator->
- Dereference object member (public member function)
Exclusive for the version specialized for arrays with runtime length:
- operator[]
- Offset access (public member function)
Non-member function overloads
- swap
- Exchange content of unique_ptr objects (function template)
- relational operators
- Relational operators ==, !=, <, <=, >, >= (function template)
Home page | Privacy policy
© cplusplus.com, 2000-2025 - All rights reserved - v3.3.4s
Spotted an error? contact us
© cplusplus.com, 2000-2025 - All rights reserved - v3.3.4s
Spotted an error? contact us