19 General utilities library [utilities]

19.11 Smart pointers [smartptr]

19.11.1 Class template unique_­ptr [unique.ptr]

19.11.1.2 unique_­ptr for single objects [unique.ptr.single]

19.11.1.2.1 Constructors [unique.ptr.single.ctor]

🔗
constexpr unique_ptr() noexcept; constexpr unique_ptr(nullptr_t) noexcept;
1
#
Requires: D shall satisfy the Cpp17DefaultConstructible requirements (Table 24), and that construction shall not throw an exception.
2
#
Effects: Constructs a unique_­ptr object that owns nothing, value-initializing the stored pointer and the stored deleter.
3
#
Ensures: get() == nullptr.
get_­deleter() returns a reference to the stored deleter.
4
#
Remarks: If is_­pointer_­v<deleter_­type> is true or is_­default_­constructible_­v<deleter_­type> is false, this constructor shall not participate in overload resolution.
🔗
explicit unique_ptr(pointer p) noexcept;
5
#
Requires: D shall satisfy the Cpp17DefaultConstructible requirements (Table 24), and that construction shall not throw an exception.
6
#
Effects: Constructs a unique_­ptr which owns p, initializing the stored pointer with p and value-initializing the stored deleter.
7
#
Ensures: get() == p.
get_­deleter() returns a reference to the stored deleter.
8
#
Remarks: If is_­pointer_­v<deleter_­type> is true or is_­default_­constructible_­v<deleter_­type> is false, this constructor shall not participate in overload resolution.
If class template argument deduction ([over.match.class.deduct]) would select the function template corresponding to this constructor, then the program is ill-formed.
🔗
unique_ptr(pointer p, see below d1) noexcept; unique_ptr(pointer p, see below d2) noexcept;
9
#
The signature of these constructors depends upon whether D is a reference type.
If D is a non-reference type A, then the signatures are:
unique_ptr(pointer p, const A& d) noexcept;
unique_ptr(pointer p, A&& d) noexcept;
10
#
If D is an lvalue reference type A&, then the signatures are:
unique_ptr(pointer p, A& d) noexcept;
unique_ptr(pointer p, A&& d) = delete;
11
#
If D is an lvalue reference type const A&, then the signatures are:
unique_ptr(pointer p, const A& d) noexcept;
unique_ptr(pointer p, const A&& d) = delete;
12
#
Requires: For the first constructor, if D is not a reference type, D shall satisfy the Cpp17CopyConstructible requirements and such construction shall not exit via an exception.
For the second constructor, if D is not a reference type, D shall satisfy the Cpp17MoveConstructible requirements and such construction shall not exit via an exception.
13
#
Effects: Constructs a unique_­ptr object which owns p, initializing the stored pointer with p and initializing the deleter from std​::​forward<decltype(d)>(d).
14
#
Remarks: These constructors shall not participate in overload resolution unless is_­constructible_­v<D, decltype(d)> is true.
15
#
Ensures: get() == p.
get_­deleter() returns a reference to the stored deleter.
If D is a reference type then get_­deleter() returns a reference to the lvalue d.
16
#
Remarks: If class template argument deduction ([over.match.class.deduct]) would select a function template corresponding to either of these constructors, then the program is ill-formed.
17
#
[ Example
: 
D d;
unique_ptr<int, D> p1(new int, D());        // D must be Cpp17MoveConstructible
unique_ptr<int, D> p2(new int, d);          // D must be Cpp17CopyConstructible
unique_ptr<int, D&> p3(new int, d);         // p3 holds a reference to d
unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object combined
                                            // with reference deleter type
— end example
 ]
🔗
unique_ptr(unique_ptr&& u) noexcept;
18
#
Requires: If D is not a reference type, D shall satisfy the Cpp17MoveConstructible requirements (Table 25).
Construction of the deleter from an rvalue of type D shall not throw an exception.
19
#
Effects: Constructs a unique_­ptr from u.
If D is a reference type, this deleter is copy constructed from u's deleter; otherwise, this deleter is move constructed from u's deleter.
[ Note
:
The construction of the deleter can be implemented with std​::​forward<D>.
— end note
 ]
20
#
Ensures: get() yields the value u.get() yielded before the construction.
u.get() == nullptr.
get_­deleter() returns a reference to the stored deleter that was constructed from u.get_­deleter().
If D is a reference type then get_­deleter() and u.get_­deleter() both reference the same lvalue deleter.
🔗
template<class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept;
21
#
Requires: If E is not a reference type, construction of the deleter from an rvalue of type E shall be well-formed and shall not throw an exception.
Otherwise, E is a reference type and construction of the deleter from an lvalue of type E shall be well-formed and shall not throw an exception.
22
#
Remarks: This constructor shall not participate in overload resolution unless:
  • (22.1)
    unique_­ptr<U, E>​::​pointer is implicitly convertible to pointer,
  • (22.2)
    U is not an array type, and
  • (22.3)
    either D is a reference type and E is the same type as D, or D is not a reference type and E is implicitly convertible to D.
23
#
Effects: Constructs a unique_­ptr from u.
If E is a reference type, this deleter is copy constructed from u's deleter; otherwise, this deleter is move constructed from u's deleter.
[ Note
:
The deleter constructor can be implemented with std​::​forward<E>.
— end note
 ]
24
#
Ensures: get() yields the value u.get() yielded before the construction.
u.get() == nullptr.
get_­deleter() returns a reference to the stored deleter that was constructed from u.get_­deleter().