std::weak_ptr< _Tp >(3)    Library Functions Manual    std::weak_ptr< _Tp >(3)

NAME
       std::weak_ptr< _Tp > - A non-owning observer for a pointer owned by a
       shared_ptr.


SYNOPSIS
       #include <memory>

       Inherits std::__weak_ptr< _Tp, _Lp >.

   Public Types
       using element_type

   Public Member Functions
       template<typename _Yp , typename  = _Constructible<const
           shared_ptr<_Yp>&>> weak_ptr (const shared_ptr< _Yp > &__r) noexcept
       weak_ptr (const weak_ptr &) noexcept=default
       template<typename _Yp , typename  = _Constructible<const
           weak_ptr<_Yp>&>> weak_ptr (const weak_ptr< _Yp > &__r) noexcept
       weak_ptr (weak_ptr &&) noexcept=default
       template<typename _Yp , typename  = _Constructible<weak_ptr<_Yp>>>
           weak_ptr (weak_ptr< _Yp > &&__r) noexcept
       bool expired () const noexcept
       shared_ptr< _Tp > lock () const noexcept
       template<typename _Yp > _Assignable< const shared_ptr< _Yp > & >
           operator= (const shared_ptr< _Yp > &__r) noexcept
       weak_ptr & operator= (const weak_ptr &__r) noexcept=default
       template<typename _Yp > _Assignable< const weak_ptr< _Yp > & >
           operator= (const weak_ptr< _Yp > &__r) noexcept
       weak_ptr & operator= (weak_ptr &&__r) noexcept=default
       template<typename _Yp > _Assignable< weak_ptr< _Yp > > operator=
           (weak_ptr< _Yp > &&__r) noexcept
       template<typename _Tp1 > bool owner_before (const __shared_ptr< _Tp1,
           _Lp > &__rhs) const noexcept
       template<typename _Tp1 > bool owner_before (const __weak_ptr< _Tp1, _Lp
           > &__rhs) const noexcept
       void reset () noexcept
       void swap (__weak_ptr &__s) noexcept
       long use_count () const noexcept

   Related Symbols
       (Note that these are not member symbols.)
       template<typename _Tp > void swap (weak_ptr< _Tp > &__a, weak_ptr< _Tp
           > &__b) noexcept
           Swap overload for weak_ptr.

Detailed Description
   template<typename _Tp>
       class std::weak_ptr< _Tp >"A non-owning observer for a pointer owned by
       a shared_ptr.



       Since
           C++11

       A weak_ptr provides a safe alternative to a raw pointer when you want a
       non-owning reference to an object that is managed by a shared_ptr.

       Unlike a raw pointer, a weak_ptr can be converted to a new shared_ptr
       that shares ownership with every other shared_ptr that already owns the
       pointer. In other words you can upgrade from a non-owning 'weak'
       reference to an owning shared_ptr, without having access to any of the
       existing shared_ptr objects.

       Also unlike a raw pointer, a weak_ptr does not become 'dangling' after
       the object it points to has been destroyed. Instead, a weak_ptr becomes
       expired and can no longer be converted to a shared_ptr that owns the
       freed pointer, so you cannot accidentally access the pointed-to object
       after it has been destroyed.


Author
       Generated automatically by Doxygen for libstdc++ from the source code.

                                   libstdc++           std::weak_ptr< _Tp >(3)