23 General utilities library [utilities]
The
weak_ptr class template stores a weak reference to an object
that is already managed by a
shared_ptr.To access the object, a
weak_ptr can be converted to a
shared_ptr using the member
function
lock.
namespace std {
template<class T> class weak_ptr {
public:
using element_type = T;
constexpr weak_ptr() noexcept;
template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
weak_ptr(const weak_ptr& r) noexcept;
template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
weak_ptr(weak_ptr&& r) noexcept;
template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
~weak_ptr();
weak_ptr& operator=(const weak_ptr& r) noexcept;
template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
weak_ptr& operator=(weak_ptr&& r) noexcept;
template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
void swap(weak_ptr& r) noexcept;
void reset() noexcept;
long use_count() const noexcept;
bool expired() const noexcept;
shared_ptr<T> lock() const noexcept;
template<class U> bool owner_before(const shared_ptr<U>& b) const;
template<class U> bool owner_before(const weak_ptr<U>& b) const;
};
template<class T> weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
}Specializations of
weak_ptr shall be
CopyConstructible and
CopyAssignable, allowing their use in standard
containers
.The template parameter
T of
weak_ptr may be an
incomplete type
.constexpr weak_ptr() noexcept;
Effects: Constructs an empty
weak_ptr object
. Postconditions: use_count() == 0. weak_ptr(const weak_ptr& r) noexcept;
template<class Y> weak_ptr(const weak_ptr<Y>& r) noexcept;
template<class Y> weak_ptr(const shared_ptr<Y>& r) noexcept;
Remarks: The second and third constructors shall not participate in
overload resolution unless
Y* is compatible with
T*. Effects: If
r is empty, constructs
an empty
weak_ptr object; otherwise, constructs
a
weak_ptr object that shares ownership
with
r and stores a copy of the pointer stored in
r. Postconditions: use_count() == r.use_count(). weak_ptr(weak_ptr&& r) noexcept;
template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept;
Remarks: The second constructor shall not participate in overload resolution unless
Y* is compatible with
T*. Effects: Move constructs a
weak_ptr instance from
r. Postconditions: *this shall contain the old value of
r. ~weak_ptr();
Effects: Destroys this
weak_ptr object but has no
effect on the object its stored pointer points to
. weak_ptr& operator=(const weak_ptr& r) noexcept;
template<class Y> weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
template<class Y> weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
Effects: Equivalent to
weak_ptr(r).swap(*this). Remarks: The implementation may meet the effects (and the
implied guarantees) via different means, without creating a temporary
. weak_ptr& operator=(weak_ptr&& r) noexcept;
template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
Effects: Equivalent to
weak_ptr(std::move(r)).swap(*this). void swap(weak_ptr& r) noexcept;
Effects: Exchanges the contents of
*this and
r. void reset() noexcept;
Effects: Equivalent to
weak_ptr().swap(*this). long use_count() const noexcept;
Returns: 0 if
*this is empty;
otherwise, the number of
shared_ptr instances
that share ownership with
*this. bool expired() const noexcept;
Returns: use_count() == 0. shared_ptr<T> lock() const noexcept;
Returns: expired() ? shared_ptr<T>() : shared_ptr<T>(*this), executed atomically
. template<class U> bool owner_before(const shared_ptr<U>& b) const;
template<class U> bool owner_before(const weak_ptr<U>& b) const;
Returns: An unspecified value such that
x.owner_before(y) defines a strict weak ordering as defined in
[alg.sorting];
under the equivalence relation defined by
owner_before,
!a.owner_before(b) && !b.owner_before(a), two
shared_ptr or
weak_ptr instances are equivalent if and only if they share ownership or are
both empty
.
template<class T>
void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
Effects: Equivalent to
a.swap(b).