std::auto_ptr (3) - Linux Manuals

std::auto_ptr: std::auto_ptr

NAME

std::auto_ptr - std::auto_ptr

Synopsis

Defined in header <memory>
template< class T > class auto_ptr; (1) (deprecated in C++11)
                                        (removed in C++17)
template<> class auto_ptr<void>; (2) (deprecated in C++11)
                                        (removed in C++17)

auto_ptr is a smart pointer that manages an object obtained via new_expression and deletes that object when auto_ptr itself is destroyed. It may be used to provide exception safety for dynamically-allocated objects, for passing ownership of dynamically-allocated objects into functions and for returning dynamically-allocated objects from functions.
Copying an auto_ptr copies the pointer and transfers ownership to the destination: both copy construction and copy assignment of auto_ptr modify their right hand arguments, and the "copy" is not equal to the original. Because of these unusual copy semantics, auto_ptr may not be placed in standard containers.
std::unique_ptr is preferred for this and other uses.
(since C++11)
2) Specialization for type void is provided, it declares the typedef element_type, but no member functions.
An additional class template auto_ptr_ref is referred to throughout the documentation. It is an implementation-defined type that holds a reference to auto_ptr. The implementation is allowed to provide the template with a different name or implement the functions returning it or accepting it as parameter in other ways.

Member types

Member type Definition
element_type T

Member functions

                         creates a new auto_ptr
constructor (public member function)
                         destroys an auto_ptr and the managed object
destructor (public member function)
                         transfers ownership from another auto_ptr
operator= (public member function)
                         converts the managed pointer to a pointer to different type
operator_auto_ptr<Y> (public member function)
operator_auto_ptr_ref<Y>

Observers

                         returns a pointer to the managed object
get (public member function)
                         accesses the managed object
operator* (public member function)
operator->

Modifiers

                         destroys the managed object
reset (public member function)
                         releases ownership of the managed object
release (public member function)