std::weak_ptr< T > Template-Klassenreferenz

#include <weak_ptr.hpp>

Öffentliche Typen
using	value_type = T
using	ref_type = long
using	element_type = value_type
using	pointer = value_type *
using	const_value_type = const value_type
using	self_type = weak_ptr< value_type >
using	shared_type = shared_ptr< value_type >

Öffentliche Methoden
	weak_ptr (value_type pValue=0)
	weak_ptr (const self_type &r)
	weak_ptr (shared_type pShrd)
template<typename other >
	weak_ptr (const weak_ptr< other > &r)
template<typename other >
	weak_ptr (const shared_ptr< other > &pShrd)
shared_type	lock ()
self_type &	operator= (const self_type &r)
ref_type	use_count () const
const bool	expired ()
void	reset ()
void	swap (self_type &other)
template<class Y >
const bool	owner_before (weak_ptr< Y > const &rhs)
template<class Y >
const bool	owner_before (shared_ptr< Y > const &rhs)
pointer	operator-> () const
const_value_type &	operator* ()
	operator bool ()

Ausführliche Beschreibung

template<typename T>
class std::weak_ptr< T >

Dokumentation der benutzerdefinierten Datentypen

const_value_type

template<typename T >

using std::weak_ptr< T >::const_value_type = const value_type

element_type

template<typename T >

using std::weak_ptr< T >::element_type = value_type

pointer

template<typename T >

using std::weak_ptr< T >::pointer = value_type*

ref_type

template<typename T >

using std::weak_ptr< T >::ref_type = long

self_type

template<typename T >

using std::weak_ptr< T >::self_type = weak_ptr<value_type>

shared_type

template<typename T >

using std::weak_ptr< T >::shared_type = shared_ptr<value_type>

value_type

template<typename T >

using std::weak_ptr< T >::value_type = T

Beschreibung der Konstruktoren und Destruktoren

weak_ptr() [1/5]

template<typename T >

std::weak_ptr< T >::weak_ptr ( value_type  pValue = 0 )

inlineexplicit

             : _m_ptr(pValue), _m_ref(new atomic<ref_type>(1))  { }

weak_ptr() [2/5]

template<typename T >

std::weak_ptr< T >::weak_ptr ( const self_type &  r )

inline

            : _m_ptr(r._m_ptr), _m_ref(r._m_ref)  { }

weak_ptr() [3/5]

template<typename T >

std::weak_ptr< T >::weak_ptr ( shared_type  pShrd )

inline

            : _m_ptr(pShrd.get()), _m_ref(new atomic<ref_type>(pShrd.ref())) {}

weak_ptr() [4/5]

template<typename T >

template<typename other >

std::weak_ptr< T >::weak_ptr ( const weak_ptr< other > &  r )

inline

            : _m_ptr(r._m_ptr), _m_ref(r._m_ref)  { }

weak_ptr() [5/5]

template<typename T >

template<typename other >

std::weak_ptr< T >::weak_ptr ( const shared_ptr< other > &  pShrd )

inline

            : _m_ptr(pShrd.get()), _m_ref(new atomic<ref_type>(pShrd.ref())) {}

Dokumentation der Elementfunktionen

expired()

template<typename T >

const bool std::weak_ptr< T >::expired ( )

inline

                             {
            return use_count() == 0;
        }

lock()

template<typename T >

shared_type std::weak_ptr< T >::lock ( void  )

inline

                           {
            return shared_ptr(_m_ptr);
        }

operator bool()

template<typename T >

std::weak_ptr< T >::operator bool ( )

inline

                        {
            return _m_ptr != 0;
        }

operator*()

template<typename T >

const_value_type& std::weak_ptr< T >::operator* ( )

inline

                                  {
            assert(get() != 0);
            return *_m_ptr;
    }

operator->()

template<typename T >

pointer std::weak_ptr< T >::operator-> ( ) const

inline

                                   {
            assert(get() != 0);
            return _m_ptr;
    }

operator=()

template<typename T >

self_type& std::weak_ptr< T >::operator= ( const self_type &  r )

inline

                                                   {
            _m_ptr = r._m_ptr;
            _m_ref = r._m_ref;
            return *this;
        }

owner_before() [1/2]

template<typename T >

template<class Y >

const bool std::weak_ptr< T >::owner_before ( weak_ptr< Y > const &  rhs )

inline

                                                           {
            return _m_ref < rhs._m_ref;
        }

owner_before() [2/2]

template<typename T >

template<class Y >

const bool std::weak_ptr< T >::owner_before ( shared_ptr< Y > const &  rhs )

inline

                                                             {
            return _m_ref < rhs.ref();
        }

reset()

template<typename T >

void std::weak_ptr< T >::reset ( )

inline

                      {
            self_type().swap(*this);
        }

swap()

template<typename T >

void std::weak_ptr< T >::swap ( self_type &  other )

inline

                                    {
            std::swap<value_type>(_m_ptr, other._m_ptr);
            _m_ref.swap(other._m_ref);
        }

use_count()

template<typename T >

ref_type std::weak_ptr< T >::use_count ( ) const

inline

                                   {
            return _m_ref->get();
        }

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/weak_ptr.hpp