libstdc++: std::auto_ptr< _Tp > Class Template Reference

libstdc++

std::auto_ptr< _Tp > Class Template Reference
Utilities » Memory » Pointer Abstractions

`#include <memory>`

## Public Types
typedef _Tp | element_type

## Public Member Functions
| 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 *__p=0) 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

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

Definition at line 93 of file auto_ptr.h.

## Member Typedef Documentation

## ◆ element_type

template<typename _Tp>

typedef _Tp std::auto_ptr< _Tp >::element_type

The pointed-to type.

Definition at line 100 of file auto_ptr.h.

## Constructor & Destructor Documentation

## ◆ auto_ptr() [1/4]

template<typename _Tp>

std::auto_ptr< _Tp >::auto_ptr | ( | element_type * | __p = 0 | ) |
throw | ( | ) |  |  |
| inlineexplicit

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

Referenced by auto_ptr(), auto_ptr(), operator=(), and operator=().

## ◆ auto_ptr() [2/4]

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

References auto_ptr().

## ◆ auto_ptr() [3/4]

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

References auto_ptr().

## ◆ ~auto_ptr()

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

## ◆ auto_ptr() [4/4]

template<typename _Tp>

std::auto_ptr< _Tp >::auto_ptr | ( | auto_ptr_ref< element_type > | __ref | ) |
throw | ( | ) |  |  |
| inline

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(.....);
std::auto_ptr::auto_ptr
auto_ptr(element_type *__p=0)
An auto_ptr is usually constructed from a raw pointer.
Definition auto_ptr.h:109

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

Definition at line 270 of file auto_ptr.h.

## Member Function Documentation

## ◆ get()

template<typename _Tp>

element_type * std::auto_ptr< _Tp >::get | ( |  | ) | 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 217 of file auto_ptr.h.

## ◆ operator auto_ptr< _Tp1 >()

template<typename _Tp>
template<typename _Tp1>

std::auto_ptr< _Tp >::operator auto_ptr< _Tp1 > | ( |  | ) |
throw | ( | ) |  |  |
| inline

Definition at line 289 of file auto_ptr.h.

## ◆ operator auto_ptr_ref< _Tp1 >()

template<typename _Tp>
template<typename _Tp1>

std::auto_ptr< _Tp >::operator auto_ptr_ref< _Tp1 > | ( |  | ) |
throw | ( | ) |  |  |
| inline

Definition at line 285 of file auto_ptr.h.

## ◆ operator*()

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

## ◆ operator->()

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

## ◆ operator=() [1/3]

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

References auto_ptr(), and reset().

## ◆ operator=() [2/3]

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

References auto_ptr(), and reset().

## ◆ operator=() [3/3]

template<typename _Tp>

auto_ptr & std::auto_ptr< _Tp >::operator= | ( | auto_ptr_ref< element_type > | __ref | ) |
throw | ( | ) |  |  |
| inline

Definition at line 274 of file auto_ptr.h.

## ◆ release()

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

## ◆ reset()

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

Referenced by operator=(), and operator=().

The documentation for this class was generated from the following files:

- shared_ptr_base.h
- auto_ptr.h