std::auto_ptr(3)std::auto_ptr(3)NAMEstd::auto_ptr-
A simple smart pointer providing strict ownership semantics.
SYNOPSIS
Public Types
typedef _Tp element_type
Public Member Functions
auto_ptr (auto_ptr_ref< element_type > __ref) throw ()
template<typename _Tp1 > auto_ptr (auto_ptr< _Tp1 > &__a) throw ()
auto_ptr (auto_ptr &__a) throw ()
auto_ptr (element_type *__p=0) throw ()
element_type * get () const throw ()
template<typename _Tp1 > operator auto_ptr< _Tp1 > () throw ()
template<typename _Tp1 > operator auto_ptr_ref< _Tp1 > () throw ()
element_type & operator* () const throw ()
element_type * operator-> () const throw ()
auto_ptr & operator= (auto_ptr_ref< element_type > __ref) throw ()
template<typename _Tp1 > auto_ptr & operator= (auto_ptr< _Tp1 > &__a)
throw ()
auto_ptr & operator= (auto_ptr &__a) throw ()
element_type * release () throw ()
void reset (element_type *__p=0) throw ()
~auto_ptr ()
Detailed Description
template<typename _Tp> class std::auto_ptr< _Tp >
A simple smart pointer providing strict ownership semantics.
The Standard says:
An auto_ptr owns the object it holds a pointer to. Copying
an auto_ptr copies the pointer and transfers ownership to the
destination. If more than one auto_ptr owns the same object
at the same time the behavior of the program is undefined.
The uses of auto_ptr include providing temporary
exception-safety for dynamically allocated memory, passing
ownership of dynamically allocated memory to a function, and
returning dynamically allocated memory from a function. auto_ptr does not meet the CopyConstructible and Assignable
requirements for Standard Library container elements and thus
instantiating a Standard Library container with an auto_ptr results in undefined behavior.
Quoted from [20.4.5]/3.
Good examples of what can and cannot be done with auto_ptr can be found
in the libstdc++ testsuite.
_GLIBCXX_RESOLVE_LIB_DEFECTS 127. auto_ptr<> conversion issues These
resolutions have all been incorporated.
Definition at line 85 of file auto_ptr.h.
Member Typedef Documentation
template<typename _Tp> typedef _Tp std::auto_ptr< _Tp >::element_type
The pointed-to type.
Definition at line 92 of file auto_ptr.h.
Constructor & Destructor Documentation
template<typename _Tp> std::auto_ptr< _Tp >::auto_ptr (element_type * __p =
0) throw () [inline, explicit]
An auto_ptr is usually constructed from a raw pointer. Parameters:
p A pointer (defaults to NULL).
This object now owns the object pointed to by p.
Definition at line 101 of file auto_ptr.h.
template<typename _Tp> std::auto_ptr< _Tp >::auto_ptr (auto_ptr< _Tp > &
__a) throw () [inline]
An auto_ptr can be constructed from another auto_ptr. Parameters:
a Another auto_ptr of the same type.
This object now owns the object previously owned by a, which has given
up ownership.
Definition at line 110 of file auto_ptr.h.
template<typename _Tp> template<typename _Tp1 > std::auto_ptr< _Tp
>::auto_ptr (auto_ptr< _Tp1 > & __a) throw () [inline]
An auto_ptr can be constructed from another auto_ptr. Parameters:
a Another auto_ptr of a different but related type.
A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type.
This object now owns the object previously owned by a, which has given
up ownership.
Definition at line 123 of file auto_ptr.h.
template<typename _Tp> std::auto_ptr< _Tp >::~auto_ptr () [inline] When the
auto_ptr goes out of scope, the object it owns is deleted. If it no
longer owns anything (i.e., get() is NULL), then this has no effect.
The C++ standard says there is supposed to be an empty throw
specification here, but omitting it is standard conforming. Its
presence can be detected only if _Tp::~_Tp() throws, but this is
prohibited. [17.4.3.6]/2
Definition at line 168 of file auto_ptr.h.
template<typename _Tp> std::auto_ptr< _Tp >::auto_ptr (auto_ptr_ref<
element_type > __ref) throw () [inline]
Automatic conversions. These operations convert an auto_ptr into and
from an auto_ptr_ref automatically as needed. This allows constructs
such as
auto_ptr<Derived> func_returning_auto_ptr(.....);
...
auto_ptr<Base> ptr = func_returning_auto_ptr(.....);
Definition at line 258 of file auto_ptr.h.
Member Function Documentation
template<typename _Tp> element_type* std::auto_ptr< _Tp >::get (void) const
throw () [inline]
Bypassing the smart pointer. Returns:
The raw pointer being managed.
You can get a copy of the pointer that this object owns, for situations
such as passing to a function which only accepts a raw pointer.
Note:
This auto_ptr still owns the memory.
Definition at line 209 of file auto_ptr.h.
template<typename _Tp> element_type& std::auto_ptr< _Tp >::operator* ()
const throw () [inline]
Smart pointer dereferencing. If this auto_ptr no longer owns anything,
then this operation will crash. (For a smart pointer, 'no longer owns
anything' is the same as being a null pointer, and you know what
happens when you dereference one of those...)
Definition at line 179 of file auto_ptr.h.
template<typename _Tp> element_type* std::auto_ptr< _Tp >::operator-> ()
const throw () [inline]
Smart pointer dereferencing. This returns the pointer itself, which the
language then will automatically cause to be dereferenced.
Definition at line 192 of file auto_ptr.h.
template<typename _Tp> template<typename _Tp1 > auto_ptr& std::auto_ptr<
_Tp >::operator= (auto_ptr< _Tp1 > & __a) throw () [inline]
auto_ptr assignment operator. Parameters:
a Another auto_ptr of a different but related type.
A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type.
This object now owns the object previously owned by a, which has given
up ownership. The object that this one used to own and track has been
deleted.
Definition at line 152 of file auto_ptr.h.
template<typename _Tp> auto_ptr& std::auto_ptr< _Tp >::operator= (auto_ptr<
_Tp > & __a) throw () [inline]
auto_ptr assignment operator. Parameters:
a Another auto_ptr of the same type.
This object now owns the object previously owned by a, which has given
up ownership. The object that this one used to own and track has been
deleted.
Definition at line 134 of file auto_ptr.h.
template<typename _Tp> element_type* std::auto_ptr< _Tp >::release ()
throw () [inline]
Bypassing the smart pointer. Returns:
The raw pointer being managed.
You can get a copy of the pointer that this object owns, for situations
such as passing to a function which only accepts a raw pointer.
Note:
This auto_ptr no longer owns the memory. When this object goes out
of scope, nothing will happen.
Definition at line 223 of file auto_ptr.h.
template<typename _Tp> void std::auto_ptr< _Tp >::reset (element_type * __p
= 0) throw () [inline]
Forcibly deletes the managed object. Parameters:
p A pointer (defaults to NULL).
This object now owns the object pointed to by p. The previous object
has been deleted.
Definition at line 238 of file auto_ptr.h.
Author
Generated automatically by Doxygen for libstdc++ from the source code.
libstdc++ 22 Nov 2013 std::auto_ptr(3)
