20 General utilities library [utilities]

20.11 Smart pointers [smartptr]

20.11.1 Class template unique_ptr [unique.ptr]

20.11.1.3 unique_ptr for array objects with a runtime length [unique.ptr.runtime]

namespace std {
  template<class T, class D> class unique_ptr<T[], D> {
  public:
    using pointer      = see below;
    using element_type = T;
    using deleter_type = D;

    // [unique.ptr.runtime.ctor], constructors
    constexpr unique_ptr() noexcept;
    template<class U> explicit unique_ptr(U p) noexcept;
    template<class U> unique_ptr(U p, see below d) noexcept;
    template<class U> unique_ptr(U p, see below d) noexcept;
    unique_ptr(unique_ptr&& u) noexcept;
    template<class U, class E>
      unique_ptr(unique_ptr<U, E>&& u) noexcept;
    constexpr unique_ptr(nullptr_t) noexcept;

    // destructor
    ~unique_ptr();

    // assignment
    unique_ptr& operator=(unique_ptr&& u) noexcept;
    template<class U, class E>
      unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
    unique_ptr& operator=(nullptr_t) noexcept;

    // [unique.ptr.runtime.observers], observers
    T& operator[](size_t i) const;
    pointer get() const noexcept;
    deleter_type& get_deleter() noexcept;
    const deleter_type& get_deleter() const noexcept;
    explicit operator bool() const noexcept;

    // [unique.ptr.runtime.modifiers], modifiers
    pointer release() noexcept;
    template<class U> void reset(U p) noexcept;
    void reset(nullptr_t = nullptr) noexcept;
    void swap(unique_ptr& u) noexcept;

    // disable copy from lvalue
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
  };
}

A specialization for array types is provided with a slightly altered interface.

(1.1)
Conversions between different types of unique_ptr<T[], D> that would be disallowed for the corresponding pointer-to-array types, and conversions to or from the non-array forms of unique_ptr, produce an ill-formed program.
(1.2)
Pointers to types derived from T are rejected by the constructors, and by reset.
(1.3)
The observers operator* and operator-> are not provided.
(1.4)
The indexing observer operator[] is provided.
(1.5)
The default deleter will call delete[].

Descriptions are provided below only for members that differ from the primary template.

The template argument T shall be a complete type.

20.11.1.3.1 Constructors [unique.ptr.runtime.ctor]

🔗

template<class U> explicit unique_ptr(U p) noexcept;

This constructor behaves the same as the constructor in the primary template that takes a single parameter of type pointer except that it additionally shall not participate in overload resolution unless

(1.1)
U is the same type as pointer, or
(1.2)
pointer is the same type as element_type*, U is a pointer type V*, and V(*)[] is convertible to element_type(*)[].

🔗

template<class U> unique_ptr(U p, see below d) noexcept;
template<class U> unique_ptr(U p, see below d) noexcept;

These constructors behave the same as the constructors in the primary template that take a parameter of type pointer and a second parameter except that they shall not participate in overload resolution unless either

(2.1)
U is the same type as pointer,
(2.2)
U is nullptr_t, or
(2.3)
pointer is the same type as element_type*, U is a pointer type V*, and V(*)[] is convertible to element_type(*)[].

🔗

template<class U, class E> unique_ptr(unique_ptr<U, E>&& u) noexcept;

This constructor behaves the same as in the primary template, except that it shall not participate in overload resolution unless all of the following conditions hold, where UP is unique_ptr<U, E>:

(3.1)
U is an array type, and
(3.2)
pointer is the same type as element_type*, and
(3.3)
UP::pointer is the same type as UP::element_type*, and
(3.4)
UP::element_type(*)[] is convertible to element_type(*)[], and
(3.5)
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.

[ Note

This replaces the overload-resolution specification of the primary template

— end note

]

20.11.1.3.2 Assignment [unique.ptr.runtime.asgn]

🔗

template<class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u)noexcept;

This operator behaves the same as in the primary template, except that it shall not participate in overload resolution unless all of the following conditions hold, where UP is unique_ptr<U, E>:

(1.1)
U is an array type, and
(1.2)
pointer is the same type as element_type*, and
(1.3)
UP::pointer is the same type as UP::element_type*, and
(1.4)
UP::element_type(*)[] is convertible to element_type(*)[], and
(1.5)
is_assignable_v<D&, E&&> is true.

[ Note

This replaces the overload-resolution specification of the primary template

— end note

]

20.11.1.3.3 Observers [unique.ptr.runtime.observers]

🔗

T& operator[](size_t i) const;

Requires: i < the number of elements in the array to which the stored pointer points.

Returns: get()[i].

20.11.1.3.4 Modifiers [unique.ptr.runtime.modifiers]

🔗

void reset(nullptr_t p = nullptr) noexcept;

Effects: Equivalent to reset(pointer()).

🔗

template<class U> void reset(U p) noexcept;

This function behaves the same as the reset member of the primary template, except that it shall not participate in overload resolution unless either

(2.1)
U is the same type as pointer, or
(2.2)
pointer is the same type as element_type*, U is a pointer type V*, and V(*)[] is convertible to element_type(*)[].