std::auto_ptr - Man Page

typedef _Tp element_type
The pointed-to type.

auto_ptr (auto_ptr &__a)  throw ()
An auto_ptr can be constructed from another auto_ptr.
template<typename _Tp1 > auto_ptr (auto_ptr< _Tp1 > &__a)  throw ()
An auto_ptr can be constructed from another auto_ptr.
auto_ptr (auto_ptr_ref< element_type > __ref)  throw ()
Automatic conversions.
auto_ptr (element_type *__p=0)  throw ()
An auto_ptr is usually constructed from a raw pointer.
~auto_ptr ()
element_type * get () const  throw ()
Bypassing the smart pointer.
template<typename _Tp1 > operator auto_ptr< _Tp1 > ()  throw ()
template<typename _Tp1 > operator auto_ptr_ref< _Tp1 > ()  throw ()
element_type & operator* () const  throw ()
Smart pointer dereferencing.
element_type * operator-> () const  throw ()
Smart pointer dereferencing.
auto_ptr & operator= (auto_ptr &__a)  throw ()
auto_ptr assignment operator.
template<typename _Tp1 > auto_ptr & operator= (auto_ptr< _Tp1 > &__a)  throw ()
auto_ptr assignment operator.
auto_ptr & operator= (auto_ptr_ref< element_type > __ref)  throw ()
element_type * release ()  throw ()
Bypassing the smart pointer.
void reset (element_type *__p=0)  throw ()
Forcibly deletes the managed object.

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.

Deprecated

Deprecated in C++11, no longer in the standard since C++17. Use unique_ptr instead.

The pointed-to type.

An auto_ptr is usually constructed from a raw pointer.

Parameters

This object now owns the object pointed to by __p.

An auto_ptr can be constructed from another auto_ptr.

Parameters

This object now owns the object previously owned by __a, which has given up ownership.

An auto_ptr can be constructed from another auto_ptr.

Parameters

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.

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

Automatic conversions. These operations are supposed to convert an auto_ptr into and from an auto_ptr_ref automatically as needed. This would allow constructs such as

auto_ptr<Derived>  func_returning_auto_ptr(.....);
...
auto_ptr<Base> ptr = func_returning_auto_ptr(.....);

But it doesn't work, and won't be fixed. For further details see http://cplusplus.github.io/LWG/lwg-closed.html#463

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.

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...)

Smart pointer dereferencing. This returns the pointer itself, which the language then will automatically cause to be dereferenced.

auto_ptr assignment operator.

Parameters

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.

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

auto_ptr assignment operator.

Parameters

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.

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

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.

Forcibly deletes the managed object.

Parameters

This object now owns the object pointed to by __p. The previous object has been deleted.

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