STD::AUTO_PTR(3cxx)

📦

version 14-20240412 · 17 versions

🦋 std::auto_ptr< _Tp > — NAME 🦋

okay so bestie, welcome to std::auto_ptr< _Tp > — the 3cxx manual page, straight out of libstdc++. it's a simple smart pointer that provides strict ownership semantics. that's the whole vibe. ✨

🌸 SYNOPSIS 🌸

#include <memory>

🎀 Public Types 🎀

typedef _Tp element_type — literally just the pointed-to type. the type of the thing being pointed at. that's it, that's the typedef. 💅

🫶 Public Member Functions 🫶

auto_ptr (auto_ptr &__a) throw () — an auto_ptr can be constructed from another auto_ptr. yes, from another one. 🌀
template<typename _Tp1 > auto_ptr (auto_ptr< _Tp1 > &__a) throw () — an auto_ptr can be constructed from another auto_ptr (this one's the templated flavor, different-ish type energy). 🦋
auto_ptr (auto_ptr_ref< element_type > __ref) throw () — automatic conversions, bestie. 🪄
auto_ptr (element_type *__p=0) throw () — an auto_ptr is usually constructed from a raw pointer. classic. 👑
~auto_ptr () — the destructor. it exists. 💀
element_type * get () const throw () — bypassing the smart pointer. 👀
template<typename _Tp1 > operator auto_ptr< _Tp1 > () throw () — conversion operator, no notes. 🌈
template<typename _Tp1 > operator auto_ptr_ref< _Tp1 > () throw () — conversion operator to the ref thingy. 🌈
element_type & operator* () const throw () — smart pointer dereferencing. ⭐
element_type * operator-> () const throw () — smart pointer dereferencing, the arrow edition. ⭐
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, templated version. 📝
auto_ptr & operator= (auto_ptr_ref< element_type > __ref) throw () — assignment from the ref. 📝
element_type * release () throw () — bypassing the smart pointer. 🚪
void reset (element_type *__p=0) throw () — forcibly deletes the managed object. no cap, forcibly. 🔥

💖 Detailed Description 💖

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

"A simple smart pointer providing strict ownership semantics." ✨

the Standard says — and I'm quoting here because the Standard is the main character:

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, if you're nosy like that. 🔍

_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. 🚨

like, for real, bestie. she's retired. use unique_ptr. 💀

🧚 Member Typedef Documentation 🧚

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

the pointed-to type. the type being pointed to. the whole point of the pointer. 💅

🌷 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. 🫶

`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. the way she just hands it over, iconic. 👑

`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. 🌀 but make it templated.

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

`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 http://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. the compiler does the ✨ work ✨ for you. 🪄

`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 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. 📝 templated. same energy, new type.

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

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

forcibly deletes the managed object. 🔥 yes, forcibly. she said what she said.

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 std::auto_ptr< _Tp >::operator=(), and std::auto_ptr< _Tp >::operator=().

👑 Author 👑

generated automatically by Doxygen for libstdc++ from the source code. 🤖 no thoughts, head empty, just docs generation.

that's the whole page, bestie!! 💜 it came to you from libstdc++, the std::auto_ptr< _Tp > (3cxx) manual — mwah, slay, go use unique_ptr instead 🎀💅✨

📦 where this page comes from

ubuntu noble: libstdc++-14-doc 14-20240412-0ubuntu1
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-06: a language model's rewrite of the original, under its terms