std::clone_ptr< T > Template-Klassenreferenz

#include <clone_ptr.hpp>

Öffentliche Typen
using	value_type = T
using	pointer = T *
using	reference = T &
using	self_type = clone_ptr< value_type >
using	cloneptrinterface = clone_ptr_interface

Öffentliche Methoden
	clone_ptr ()
	clone_ptr (T *v)
	clone_ptr (save_ptr const &other)
clone_ptr const &	operator= (clone_ptr const &other)
	~clone_ptr ()
value_type const *	get () const
value_type *	get ()
value_type const &	operator* () const
value_type &	operator* ()
value_type const *	operator-> () const
value_type *	operator-> ()
value_type *	release ()
void	reset (value_type *p=NULL)
void	swap (self_type &other)

Geschützte Methoden
cloneptrinterface *	clone ()

Ausführliche Beschreibung

template<typename T = std::clone_ptr_interface>
class std::clone_ptr< T >

Dokumentation der benutzerdefinierten Datentypen

cloneptrinterface

template<typename T = std::clone_ptr_interface>

using std::clone_ptr< T >::cloneptrinterface = clone_ptr_interface

pointer

template<typename T = std::clone_ptr_interface>

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

reference

template<typename T = std::clone_ptr_interface>

using std::clone_ptr< T >::reference = T&

self_type

template<typename T = std::clone_ptr_interface>

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

value_type

template<typename T = std::clone_ptr_interface>

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

Beschreibung der Konstruktoren und Destruktoren

clone_ptr() [1/3]

template<typename T = std::clone_ptr_interface>

std::clone_ptr< T >::clone_ptr ( )

inline

: m_ptr(0) { }

clone_ptr() [2/3]

template<typename T = std::clone_ptr_interface>

std::clone_ptr< T >::clone_ptr ( T *  v )

inlineexplicit

: m_ptr(v) { }

clone_ptr() [3/3]

template<typename T = std::clone_ptr_interface>

std::clone_ptr< T >::clone_ptr ( save_ptr const &  other )

inline

                                         {
            if(other.get() != NULL)
                m_ptr = other->clone();
        }

~clone_ptr()

template<typename T = std::clone_ptr_interface>

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

inline

                     {
            if(m_ptr) delete m_ptr;
        }

Dokumentation der Elementfunktionen

clone()

template<typename T = std::clone_ptr_interface>

cloneptrinterface* std::clone_ptr< T >::clone ( )

inlineprotected

        {
            if(m_ptr != NULL)
                return m_ptr->clone();
        }

get() [1/2]

template<typename T = std::clone_ptr_interface>

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

inline

                                      {
            return m_ptr; 
        }

get() [2/2]

template<typename T = std::clone_ptr_interface>

value_type* std::clone_ptr< T >::get ( )

inline

                          { 
            return m_ptr; 
        }

operator*() [1/2]

template<typename T = std::clone_ptr_interface>

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

inline

                                             { 
            return *m_ptr; 
        }

operator*() [2/2]

template<typename T = std::clone_ptr_interface>

value_type& std::clone_ptr< T >::operator* ( )

inline

                                 { 
            return *m_ptr; 
        }

operator->() [1/2]

template<typename T = std::clone_ptr_interface>

value_type const* std::clone_ptr< T >::operator-> ( ) const

inline

                                             {
            return m_ptr; 
        }

operator->() [2/2]

template<typename T = std::clone_ptr_interface>

value_type* std::clone_ptr< T >::operator-> ( )

inline

                                 { 
            return m_ptr; 
        }

operator=()

template<typename T = std::clone_ptr_interface>

clone_ptr const& std::clone_ptr< T >::operator= ( clone_ptr< T > const &  other )

inline

                                                           {
            if(other != this) {
                clone_ptr tmp(other);
                swap(tmp);
            }
            return *this;
        }

release()

template<typename T = std::clone_ptr_interface>

value_type* std::clone_ptr< T >::release ( )

inline

                              { 
            value_type *tmp = m_ptr; 
            m_ptr = NULL; 
            return tmp; 
        }       

reset()

template<typename T = std::clone_ptr_interface>

void std::clone_ptr< T >::reset ( value_type *  p = NULL )

inline

        {
            if(m_ptr) delete m_ptr;
                m_ptr = p;
        }

swap()

template<typename T = std::clone_ptr_interface>

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

inline

        {                         
            value_type *tmp = other.m_ptr;
            other.m_ptr = m_ptr;
            m_ptr = tmp;
        }

---

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

• include/clone_ptr.hpp