STD::AUTO_PTR(3)

💖 NAME 💖

std::auto_ptr< _Tp > — a simple smart pointer providing strict ownership semantics. She's from the Library Functions Manual, section 3, and she's got lore. ✨

---

🦋 SYNOPSIS 🦋

#include <memory>

🌸 Public Types 🌸

• typedef _Tp element_type — the pointed-to type. that's the type of the thing she's holding, bestie 💅

🎀 Public Member Functions 🎀

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

---

🌈 Detailed Description 🌈

template<typename _Tp>
class std::auto_ptr< _Tp >

"A simple smart pointer providing strict ownership semantics."

Okay so the Standard has opinions, and here's what it says, word for word:

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.

So like… copy = transfer. Two owners = undefined behavior. Putting one in a standard container = also undefined behavior. Noted. 🫶

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. 💀 she's a legacy icon, fr fr, but please move on.

---

🌟 Member Typedef Documentation 🌟

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

The pointed-to type. 🎯

---

🧚 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. 👑

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

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. (she handed it over, no take-backs 💅)

References auto_ptr().

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

References 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

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

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

---

💜 Member Function Documentation 💜

template<typename _Tp> element_type * std::auto_ptr< _Tp >::get () 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.

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…) 💀

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

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

References auto_ptr(), and 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. 🪦

References auto_ptr(), and 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. 🙈

template<typename _Tp> void std::auto_ptr< _Tp >::reset (element_type * __p = 0) [inline]

Forcibly deletes the managed object. (she said forcibly, okay? 👑)

Parameters

• __p — a pointer (defaults to NULL).

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

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

---

👑 Author 👑

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

---

and that's the whole page, bestie 🫶 this lil manual page lives in libstdc++, and it's the std::auto_ptr< _Tp >(3) entry — so if you ever need to cite her, that's the name, that's the number, that's the section. mwah 💅✨