[util.smartptr.weak] (original) (raw)

20 Memory management library [mem]

20.3 Smart pointers [smartptr]

20.3.2 Shared-ownership pointers [util.sharedptr]

20.3.2.3 Class template weak_ptr [util.smartptr.weak]

20.3.2.3.1 General [util.smartptr.weak.general]

The weak_ptr class template stores a weak reference to an object that is already managed by a shared_ptr.

To access the object, aweak_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 = remove_extent_t<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& b) const noexcept;template<class U> bool owner_before(const weak_ptr& b) const noexcept; size_t owner_hash() const noexcept;template<class U> bool owner_equal(const shared_ptr& b) const noexcept;template<class U> bool owner_equal(const weak_ptr& b) const noexcept;};template<class T> weak_ptr(shared_ptr<T>) -> weak_ptr<T>;}

The template parameter T of weak_ptr may be an incomplete type.

20.3.2.3.2 Constructors [util.smartptr.weak.const]

constexpr weak_ptr() noexcept;

Effects: Constructs an empty weak_ptr object that stores a null pointer value.

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;

Constraints: For the second and third constructors, Y* is compatible with T*.

Effects: If r is empty, constructs an empty weak_ptr object that stores a null pointer value; 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;

Constraints: For the second constructor, Y* is compatible with T*.

Effects: Move constructs a weak_ptr instance from r.

Postconditions: *this contains the old value of r.

r is empty, stores a null pointer value, and r.use_count() == 0.

20.3.2.3.3 Destructor [util.smartptr.weak.dest]

Effects: Destroys this weak_ptr object but has no effect on the object its stored pointer points to.

20.3.2.3.4 Assignment [util.smartptr.weak.assign]

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 object.

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).

20.3.2.3.5 Modifiers [util.smartptr.weak.mod]

void swap(weak_ptr& r) noexcept;

Effects: Exchanges the contents of *this and r.

Effects: Equivalent to weak_ptr().swap(*this).

20.3.2.3.6 Observers [util.smartptr.weak.obs]

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& b) const noexcept;template<class U> bool owner_before(const weak_ptr& b) const noexcept;

Returns: An unspecified value such that

owner_before(b) defines a strict weak ordering as defined in [alg.sorting];
!owner_before(b) && !b.owner_before(*this) is trueif and only if owner_equal(b) is true.

size_t owner_hash() const noexcept;

Returns: An unspecified value such that, for any object x where owner_equal(x) is true,owner_hash() == x.owner_hash() is true.

template<class U> bool owner_equal(const shared_ptr& b) const noexcept;template<class U> bool owner_equal(const weak_ptr& b) const noexcept;

Returns: true if and only if*this and b share ownership or are both empty.

Otherwise returns false.

Remarks: owner_equal is an equivalence relation.

20.3.2.3.7 Specialized algorithms [util.smartptr.weak.spec]

template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;

Effects: Equivalent to a.swap(b).