NAME

       std::auto_ptr< _Tp > -

SYNOPSIS

   Public Types
       typedef _Tp element_type

   Public Member Functions
       auto_ptr (element_type *__p=0)  throw ()
       auto_ptr (auto_ptr &__a)  throw ()
       template<typename _Tp1 > auto_ptr (auto_ptr< _Tp1 > &__a)  throw ()
       auto_ptr (auto_ptr_ref< element_type > __ref)  throw ()
       ~auto_ptr ()
       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 &__a)  throw ()
       template<typename _Tp1 > auto_ptr & operator= (auto_ptr< _Tp1 > &__a)  throw ()
       auto_ptr & operator= (auto_ptr_ref< element_type > __ref)  throw ()
       element_type * release ()  throw ()
       void reset (element_type *__p=0)  throw ()

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 87 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 94 of file auto_ptr.h.

Constructor & Destructor Documentation

   template<typename _Tp> std::auto_ptr< _Tp >::auto_ptr (element_type *__p = 0) [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 103 of file auto_ptr.h.

   template<typename _Tp> std::auto_ptr< _Tp >::auto_ptr (auto_ptr< _Tp > &__a) [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 112 of file auto_ptr.h.

   template<typename  _Tp>  template<typename  _Tp1  >  std::auto_ptr<  _Tp  >::auto_ptr (auto_ptr< _Tp1 > &__a)
       [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 125 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 170 of file auto_ptr.h.

   template<typename _Tp> std::auto_ptr< _Tp >::auto_ptr (auto_ptr_ref< element_type >__ref) [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 260 of file auto_ptr.h.

Member Function Documentation

   template<typename _Tp> element_type* std::auto_ptr< _Tp >::get (void) const [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 211 of file auto_ptr.h.

   template<typename _Tp> element_type& std::auto_ptr< _Tp >::operator* () const [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 181 of file auto_ptr.h.

   template<typename _Tp> element_type* std::auto_ptr< _Tp >::operator-> () const [inline]
       Smart  pointer dereferencing. This returns the pointer itself, which the language then will automatically
       cause to be dereferenced.

       Definition at line 194 of file auto_ptr.h.

   template<typename _Tp> auto_ptr& std::auto_ptr< _Tp >::operator= (auto_ptr< _Tp > &__a) [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 136 of file auto_ptr.h.

       References std::auto_ptr< _Tp >::reset().

   template<typename _Tp> template<typename _Tp1 > auto_ptr& std::auto_ptr< _Tp >::operator= (auto_ptr<  _Tp1  >
       &__a) [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 154 of file auto_ptr.h.

       References std::auto_ptr< _Tp >::reset().

   template<typename _Tp> element_type* std::auto_ptr< _Tp >::release () [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 225 of file auto_ptr.h.

   template<typename _Tp> void std::auto_ptr< _Tp >::reset (element_type *__p = 0) [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 240 of file auto_ptr.h.

       Referenced by std::auto_ptr< _Tp >::operator=().

Author

       Generated automatically by Doxygen for libstdc++ from the source code.

libstdc++                                        Thu Mar 20 2014                      std::auto_ptr< _Tp >(3cxx)