libstdc++: std::weak_ptr< _Tp > Class Template Reference

libstdc++

std::weak_ptr< _Tp > Class Template Reference
Utilities » Memory » Pointer Abstractions

`#include <memory>`

## 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

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

Definition at line 810 of file bits/shared_ptr.h.

## Member Typedef Documentation

## ◆ element_type

template<typename _Tp, _Lock_policy _Lp>

using std::__weak_ptr< _Tp, _Lp >::element_type
| inherited

Definition at line 2080 of file shared_ptr_base.h.

## Constructor & Destructor Documentation

## ◆ weak_ptr() [1/3]

template<typename _Tp>
template<typename _Yp, typename = _Constructible<const shared_ptr<_Yp>&>>

std::weak_ptr< _Tp >::weak_ptr | ( | const shared_ptr< _Yp > & | __r | ) |
| inlinenoexcept

Definition at line 827 of file bits/shared_ptr.h.

## ◆ weak_ptr() [2/3]

template<typename _Tp>
template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>

std::weak_ptr< _Tp >::weak_ptr | ( | const weak_ptr< _Yp > & | __r | ) |
| inlinenoexcept

Definition at line 833 of file bits/shared_ptr.h.

## ◆ weak_ptr() [3/3]

template<typename _Tp>
template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>>

std::weak_ptr< _Tp >::weak_ptr | ( | weak_ptr< _Yp > && | __r | ) |
| inlinenoexcept

Definition at line 839 of file bits/shared_ptr.h.

## Member Function Documentation

## ◆ expired()

template<typename _Tp, _Lock_policy _Lp>

bool std::__weak_ptr< _Tp, _Lp >::expired | ( |  | ) | const
| inlinenoexceptinherited

Definition at line 2217 of file shared_ptr_base.h.

## ◆ lock()

template<typename _Tp>

shared_ptr< _Tp > std::weak_ptr< _Tp >::lock | ( |  | ) | const
| inlinenoexcept

Definition at line 873 of file bits/shared_ptr.h.

## ◆ operator=() [1/3]

template<typename _Tp>
template<typename _Yp>

_Assignable< const shared_ptr< _Yp > & > std::weak_ptr< _Tp >::operator= | ( | const shared_ptr< _Yp > & | __r | ) |
| inlinenoexcept

Definition at line 855 of file bits/shared_ptr.h.

## ◆ operator=() [2/3]

template<typename _Tp>
template<typename _Yp>

_Assignable< const weak_ptr< _Yp > & > std::weak_ptr< _Tp >::operator= | ( | const weak_ptr< _Yp > & | __r | ) |
| inlinenoexcept

Definition at line 847 of file bits/shared_ptr.h.

## ◆ operator=() [3/3]

template<typename _Tp>
template<typename _Yp>

_Assignable< weak_ptr< _Yp > > std::weak_ptr< _Tp >::operator= | ( | weak_ptr< _Yp > && | __r | ) |
| inlinenoexcept

Definition at line 866 of file bits/shared_ptr.h.

## ◆ owner_before() [1/2]

template<typename _Tp, _Lock_policy _Lp>
template<typename _Tp1>

bool std::__weak_ptr< _Tp, _Lp >::owner_before | ( | const __shared_ptr< _Tp1, _Lp > & | __rhs | ) | const
| inlinenoexceptinherited

Definition at line 2222 of file shared_ptr_base.h.

## ◆ owner_before() [2/2]

template<typename _Tp, _Lock_policy _Lp>
template<typename _Tp1>

bool std::__weak_ptr< _Tp, _Lp >::owner_before | ( | const __weak_ptr< _Tp1, _Lp > & | __rhs | ) | const
| inlinenoexceptinherited

Definition at line 2227 of file shared_ptr_base.h.

## ◆ reset()

template<typename _Tp, _Lock_policy _Lp>

void std::__weak_ptr< _Tp, _Lp >::reset | ( |  | ) |
| inlinenoexceptinherited

Definition at line 2245 of file shared_ptr_base.h.

## ◆ swap()

template<typename _Tp, _Lock_policy _Lp>

void std::__weak_ptr< _Tp, _Lp >::swap | ( | __weak_ptr< _Tp, _Lp > & | __s | ) |
| inlinenoexceptinherited

Definition at line 2249 of file shared_ptr_base.h.

## ◆ use_count()

template<typename _Tp, _Lock_policy _Lp>

long std::__weak_ptr< _Tp, _Lp >::use_count | ( |  | ) | const
| inlinenoexceptinherited

Definition at line 2213 of file shared_ptr_base.h.

The documentation for this class was generated from the following file:

- bits/shared_ptr.h