std::auto_ptr< T > Template-Klassenreferenz

#include <auto_ptr.hpp>

Klassendiagramm für std::auto_ptr< T >:

Zusammengehörigkeiten von std::auto_ptr< T >:

Öffentliche Typen
using	value_type = T
using	pointer = T *
using	self_type = auto_ptr< value_type >

Öffentliche Methoden
	auto_ptr (value_type *px=0)
template<class To >
	auto_ptr (auto_ptr< To > &r)
	auto_ptr (const self_type &r)
	auto_ptr (auto_ptr_ref< value_type > r)
	~auto_ptr ()
pointer	release ()
void	reset (pointer px=0)
pointer	operator-> () const
value_type &	operator* () const
self_type &	operator= (auto_ptr_ref< value_type > r)
self_type &	operator= (self_type &r)
template<class T1 >
	operator auto_ptr_ref< T1 > ()
template<class T1 >
	operator auto_ptr< T1 > ()
value_type *	get () const
void	set (const volatile void *p)
void	set (void *p)

Geschützte Attribute
void *	_M_p

Ausführliche Beschreibung

template<class T>
class std::auto_ptr< T >

Dokumentation der benutzerdefinierten Datentypen

pointer

template<class T>

using std::auto_ptr< T >::pointer = T*

self_type

template<class T>

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

value_type

template<class T>

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

Beschreibung der Konstruktoren und Destruktoren

auto_ptr() [1/4]

template<class T>

std::auto_ptr< T >::auto_ptr ( value_type *  px = 0 )

inlineexplicit

            { this->set(px); }

auto_ptr() [2/4]

template<class T>

template<class To >

std::auto_ptr< T >::auto_ptr ( auto_ptr< To > &  r )

inline

            { pointer conversionCheck = r.release(); this->set(conversionCheck); }

auto_ptr() [3/4]

template<class T>

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

inline

            { this->set(r.release()); }

auto_ptr() [4/4]

template<class T>

std::auto_ptr< T >::auto_ptr ( auto_ptr_ref< value_type >  r )

inline

            { this->set(r.release());  }

~auto_ptr()

template<class T>

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

inline

            { delete this->get(); }

Dokumentation der Elementfunktionen

get()

template<class T>

value_type* std::auto_ptr< T >::get ( ) const

inline

                                { 
            return static_cast<value_type*>(_M_p); 
    }

operator auto_ptr< T1 >()

template<class T>

template<class T1 >

std::auto_ptr< T >::operator auto_ptr< T1 > ( )

inline

                                { 
            return auto_ptr<T1>(release()); 
    }

operator auto_ptr_ref< T1 >()

template<class T>

template<class T1 >

std::auto_ptr< T >::operator auto_ptr_ref< T1 > ( )

inline

                                    { 
            return auto_ptr_ref<T1>(*this, this->get()); 
    }

operator*()

template<class T>

value_type& std::auto_ptr< T >::operator* ( ) const

inline

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

operator->()

template<class T>

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

inline

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

operator=() [1/2]

template<class T>

self_type& std::auto_ptr< T >::operator= ( auto_ptr_ref< value_type >  r )

inline

                                                      {
            reset(r.release());
            return *this;
    }

operator=() [2/2]

template<class T>

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

inline

                                        {
            reset(r.release());
            return *this;
    }

release()

template<class T>

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

inline

            { pointer px = this->get(); this->set((void*)0); return px; }

reset()

template<class T>

void std::auto_ptr< T >::reset ( pointer  px = 0 )

inline

                               { 
            pointer pt = this->get();
        if (px != pt) delete pt;
            this->set(px);
    }

set() [1/2]

void std::__auto_ptr_base::set ( const volatile void *  p )

inlineinherited

                                          { 
            _M_p = const_cast<void*>(p); 
    }

set() [2/2]

void std::__auto_ptr_base::set ( void *  p )

inlineinherited

                       { 
            _M_p = p; 
    }

Dokumentation der Datenelemente

_M_p

void* std::__auto_ptr_base::_M_p

protectedinherited

---

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

• include/auto_ptr.hpp