--- name: "std::auto_ptr" section: "3" platform: "linux" package: "gcc" version: "16.2.1+r23+gd564253eb6c8-1" release: "Arch Linux 2026-11-01" platforms: ["linux"] url: "https://new.carta.tech/std::auto_ptr" --- # std::auto\_ptr(3) A simple smart pointer providing strict ownership semantics. ## NAME std::auto\_ptr\< \_Tp \> - A simple smart pointer providing strict ownership semantics. ## SYNOPSIS \#include \ ### Public Types typedef \_Tp **element\_type**\ The pointed-to type. ### Public Member Functions **auto\_ptr** (auto\_ptr &\_\_a) throw ()\ An auto\_ptr can be constructed from another auto\_ptr. template\ **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\ **operator auto\_ptr\< \_Tp1 \>** () throw ()\ template\ **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\ **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\ 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. ## Member Typedef Documentation ### template\ typedef \_Tp std::auto\_ptr\< \_Tp \>::element\_type The pointed-to type. ## Constructor & Destructor Documentation ### template\ 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\ 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. References **auto\_ptr()**. ### template\ template\ 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\ 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\ 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 func_returning_auto_ptr(.....); ... auto_ptr 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\ 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\ 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\ 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\ 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\ template\ 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\ 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\ void std::auto\_ptr\< \_Tp \>::reset (element\_type \* \_\_p = 0) \[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. Referenced by **operator=()**, and **operator=()**. ## Author Generated automatically by Doxygen for libstdc++ from the source code.