std::scoped_ptr< T > Template-Klassenreferenz

#include <scoped_ptr.hpp>

Öffentliche Typen
using	value_type = T
using	pointer = value_type *
using	const_value_type = const value_type
using	self_type = scoped_ptr< value_type >

Öffentliche Methoden
	scoped_ptr (pointer pValue=0)
	scoped_ptr (const auto_ptr< value_type > &pPtr)
	~scoped_ptr ()
void	swap (self_type &b)
void	reset (pointer pValue=0)
pointer	get ()
const pointer	operator-> ()
const_value_type &	operator* ()
	operator bool ()

Ausführliche Beschreibung

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

Dokumentation der benutzerdefinierten Datentypen

const_value_type

template<typename T >

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

pointer

template<typename T >

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

self_type

template<typename T >

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

value_type

template<typename T >

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

Beschreibung der Konstruktoren und Destruktoren

scoped_ptr() [1/2]

template<typename T >

std::scoped_ptr< T >::scoped_ptr ( pointer  pValue = 0 )

inlineexplicit

            : m_pPointer( pValue ) { }

scoped_ptr() [2/2]

template<typename T >

std::scoped_ptr< T >::scoped_ptr ( const auto_ptr< value_type > &  pPtr )

inlineexplicit

            : m_pPointer( pPtr.release() ) { }

~scoped_ptr()

template<typename T >

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

inline

{ }

Dokumentation der Elementfunktionen

get()

template<typename T >

pointer std::scoped_ptr< T >::get ( )

inline

            { return m_pPointer; }

operator bool()

template<typename T >

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

inline

                        {
                return m_pPointer != 0;
            }

operator*()

template<typename T >

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

inline

                                       {
            assert(m_pPointer != 0);
            return *m_pPointer;
        }

operator->()

template<typename T >

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

inline

                                     {
            assert(m_pPointer != 0);
            return m_pPointer;
        }

reset()

template<typename T >

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

inline

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

swap()

template<typename T >

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

inline

                                {
            std::swap<value_type*>(m_pPointer, b.m_pPointer);
        }

---

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

• include/scoped_ptr.hpp