std::shared_ptr< T > Template-Klassenreferenz

#include <shared_ptr.hpp>

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

Öffentliche Methoden
	shared_ptr (pointer ptr)
	shared_ptr (const self_type &sp)
	~shared_ptr ()
pointer	release ()
void	reset (pointer pValue=0)
pointer	get () const
ref_type	ref ()
void	swap (self_type &b)
self_type &	operator= (self_type &sp)
pointer	operator-> () const
const_value_type &	operator* ()
	operator bool ()

Ausführliche Beschreibung

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

Dokumentation der benutzerdefinierten Datentypen

const_value_type

template<typename T >

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

pointer

template<typename T >

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

ref_type

template<typename T >

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

self_type

template<typename T >

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

value_type

template<typename T >

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

Beschreibung der Konstruktoren und Destruktoren

shared_ptr() [1/2]

template<typename T >

std::shared_ptr< T >::shared_ptr ( pointer  ptr )

inlineexplicit

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

shared_ptr() [2/2]

template<typename T >

std::shared_ptr< T >::shared_ptr ( const self_type &  sp )

inline

                                            {
                if (++(*_m_ref) != 1) {
                    _m_ptr = sp._m_ptr;
                }
                else
                {
                    //tried to copy a shared pointer targeted for deletion
                }
            }

~shared_ptr()

template<typename T >

std::shared_ptr< T >::~shared_ptr ( )

inline

                          { 
                if (--(*_m_ref) == 0) {
                    delete _m_ptr;
                    delete _m_ref;
                }
            }

Dokumentation der Elementfunktionen

get()

template<typename T >

pointer std::shared_ptr< T >::get ( ) const

inline

                                { 
        return static_cast<T*>(_m_ptr);
        }

operator bool()

template<typename T >

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

inline

                            {
                return _m_ptr != 0;
            }

operator*()

template<typename T >

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

inline

                                      {
        assert(get() != 0);
        return *this->get();
        }

operator->()

template<typename T >

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

inline

                                   {
        assert(get() != 0);
        return this->get();
        }

operator=()

template<typename T >

self_type& std::shared_ptr< T >::operator= ( self_type &  sp )

inline

                                                  {
                release();                
                _m_ptr = sp._m_ptr;
                _m_ref = sp._m_ref;
                return *this;
            }

ref()

template<typename T >

ref_type std::shared_ptr< T >::ref ( )

inline

                           {
                return _m_ref->get();
            }

release()

template<typename T >

pointer std::shared_ptr< T >::release ( )

inline

                              {
                pointer __px = this->get();
                if (--(*_m_ref) == 0) {
                    delete _m_ptr;
                    delete _m_ref;
                }
                return __px;
            }

reset()

template<typename T >

void std::shared_ptr< T >::reset ( pointer  pValue = 0 )

inline

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

swap()

template<typename T >

void std::shared_ptr< T >::swap ( self_type &  b )

inline

                                    {
                std::swap<value_type*>(_m_ptr, b._m_ptr);
                std::swap<atomic<ref_type>*>(_m_ref, b._m_ref);
            }

---

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

• include/shared_ptr.hpp