23 General utilities library [utilities]
In the constructor definitions below,
enables
shared_from_this with
p,
for a pointer
p of type
Y*,
means that if
Y has an unambiguous and accessible base class
that is a specialization of
enable_shared_from_this (
[util.smartptr.enab]),
then
remove_cv_t<Y>* shall be implicitly convertible to
T* and
the constructor evaluates the statement:
if (p != nullptr && p->weak_this.expired())
p->weak_this = shared_ptr<remove_cv_t<Y>>(*this, const_cast<remove_cv_t<Y>*>(p));
The assignment to the
weak_this member is not atomic and
conflicts with any potentially concurrent access to the same object (
[intro.multithread])
.constexpr shared_ptr() noexcept;
Effects: Constructs an empty
shared_ptr object
. Postconditions: use_count() == 0 && get() == nullptr. template<class Y> explicit shared_ptr(Y* p);
Requires: Y shall be a complete type
. The expression
delete[] p, when
T is an array type, or
delete p, when
T is not an array type,
shall have well-defined behavior, and
shall not throw exceptions
.Effects: When
T is not an array type,
constructs a
shared_ptr object
that owns the pointer
p. Otherwise, constructs a
shared_ptr
that owns
p and a deleter of an
unspecified type that calls
delete[] p.When
T is not an array type,
enables
shared_from_this with
p.If an exception is thrown,
delete p is called
when
T is not an array type,
delete[] p otherwise
.Postconditions: use_count() == 1 && get() == p. Throws: bad_alloc, or an
implementation-defined exception when a resource other than memory could not be obtained
. Remarks: When
T is an array type,
this constructor shall not participate in overload resolution unless
the expression
delete[] p is well-formed and either
T is
U[N] and
Y(*)[N] is convertible to
T*, or
T is
U[] and
Y(*)[] is convertible to
T*. When
T is not an array type,
this constructor shall not participate in overload resolution unless
the expression
delete p is well-formed and
Y* is convertible to
T*.template<class Y, class D> shared_ptr(Y* p, D d);
template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
template <class D> shared_ptr(nullptr_t p, D d);
template <class D, class A> shared_ptr(nullptr_t p, D d, A a);
Requires: Construction of
d and a deleter of type
D
initialized with
std::move(d) shall not throw exceptions
. The expression
d(p)
shall have well-defined behavior and shall not throw exceptions
.Effects: Constructs a
shared_ptr object that owns the
object
p and the deleter
d. When
T is not an array type,
the first and second constructors enable
shared_from_this with
p.The second and fourth constructors shall use a copy of
a to
allocate memory for internal use
.If an exception is thrown,
d(p) is called
.Postconditions: use_count() == 1 && get() == p. Throws: bad_alloc, or an
implementation-defined exception
when a resource other than memory could not be obtained
. Remarks:
When
T is an array type,
this constructor shall not participate in overload resolution unless
is_move_constructible_v<D> is
true,
the expression
d(p) is well-formed, and either
T is
U[N] and
Y(*)[N] is convertible to
T*, or
T is
U[] and
Y(*)[] is convertible to
T*. When
T is not an array type,
this constructor shall not participate in overload resolution unless
is_move_constructible_v<D> is
true,
the expression
d(p) is well-formed, and
Y* is convertible to
T*.template<class Y> shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
Effects: Constructs a
shared_ptr instance that
stores
p and shares ownership with
r. Postconditions: get() == p && use_count() == r.use_count(). [
Note: To avoid the possibility of a dangling pointer, the
user of this constructor must ensure that
p remains valid at
least until the ownership group of
r is destroyed
. —
end note ]
[
Note: This constructor allows creation of an empty
shared_ptr instance with a non-null stored pointer
. —
end note ]
shared_ptr(const shared_ptr& r) noexcept;
template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
Remarks:
The second constructor shall not participate in overload resolution unless
Y* is compatible with
T*. Effects: If
r is empty, constructs
an empty
shared_ptr object; otherwise, constructs
a
shared_ptr object that shares ownership with
r. Postconditions: get() == r.get() && use_count() == r.use_count(). shared_ptr(shared_ptr&& r) noexcept;
template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
Remarks: The second constructor shall not participate in overload resolution unless
Y* is compatible with
T*. Effects: Move constructs a
shared_ptr instance from
r. Postconditions: *this shall contain the old value of
r. template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
Effects: Constructs a
shared_ptr object that shares ownership with
r and stores a copy of the pointer stored in
r. If an exception is thrown, the constructor has no effect
.Postconditions: use_count() == r.use_count(). Throws: bad_weak_ptr when
r.expired(). Remarks: This constructor shall not participate in overload resolution unless
Y* is compatible with
T*. template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
Remarks: This constructor shall not participate in overload resolution
unless
Y* is compatible with
T* and
unique_ptr<Y, D>::pointer is convertible to
element_type*. Effects: If
r.get() == nullptr, equivalent to
shared_ptr(). Otherwise, if
D is not a reference type,
equivalent to
shared_ptr(r.release(), r.get_deleter()).Otherwise, equivalent to
shared_ptr(r.release(), ref(r.get_deleter())).If an exception is thrown, the constructor has no effect
.