auto_ptr
In the C++ programming language, auto_ptr is an obsolete smart pointer class template that was available in previous versions of the C++ standard library (declared in the <memory> header file), which provides some basic RAII features for C++ raw pointers. It has been replaced by the unique_ptr class.
The auto_ptr template class describes an object that stores a pointer to a single allocated object that ensures that the object to which it points gets destroyed automatically when control leaves a scope.[1]
The characteristics of auto_ptr are now considered unsatisfactory: it was introduced before C++11's move semantics, so it uses copying for what should be done with moves (and confusingly sets the copied-from auto_ptr to a NULL pointer). These copy semantics mean that it cannot be used in STL containers.[2]
The C++11 standard made auto_ptr deprecated, replacing it with the unique_ptr class template.[3][4] auto_ptr was fully removed in C++17.[5]
For shared ownership, the shared_ptr template class can be used. shared_ptr was defined in C++11 and is also available in the Boost library for use with previous C++ versions.[6]
Declaration
[edit]The auto_ptr class is declared in ISO/IEC 14882, section 20.4.5 as:
namespace std {
template <class Y> struct auto_ptr_ref {};
template <class X>
class auto_ptr {
public:
typedef X element_type;
// 20.4.5.1 construct/copy/destroy:
explicit auto_ptr(X* p =0) throw();
auto_ptr(auto_ptr&) throw();
template <class Y> auto_ptr(auto_ptr<Y>&) throw();
auto_ptr& operator=(auto_ptr&) throw();
template <class Y> auto_ptr& operator=(auto_ptr<Y>&) throw();
auto_ptr& operator=(auto_ptr_ref<X>) throw();
~auto_ptr() throw();
// 20.4.5.2 members:
X& operator*() const throw();
X* operator->() const throw();
X* get() const throw();
X* release() throw();
void reset(X* p =0) throw();
// 20.4.5.3 conversions:
auto_ptr(auto_ptr_ref<X>) throw();
template <class Y> operator auto_ptr_ref<Y>() throw();
template <class Y> operator auto_ptr<Y>() throw();
};
}
Semantics
[edit]The auto_ptr has semantics of strict ownership, meaning that the auto_ptr instance is the sole entity responsible for the object's lifetime. If an auto_ptr is copied, the source loses the reference. For example:
#include <iostream>
#include <memory>
using namespace std;
int main(int argc, char **argv)
{
int *i = new int;
auto_ptr<int> x(i);
auto_ptr<int> y;
y = x;
cout << x.get() << endl; // Print NULL
cout << y.get() << endl; // Print non-NULL address i
return 0;
}
This code will print a NULL address for the first auto_ptr object and some non-NULL address for the second, showing that the source object lost the reference during the assignment (=). The raw pointer i in the example should not be deleted, as it will be deleted by the auto_ptr that owns the reference. In fact, new int could be passed directly into x, eliminating the need for i.
Notice that the object pointed by an auto_ptr is destroyed using operator delete; this means that you should only use auto_ptr for pointers obtained with operator new. This excludes pointers returned by malloc/calloc/realloc, and pointers to arrays (because arrays are allocated by operator new[] and must be deallocated by operator delete[]).
Because of its copy semantics, auto_ptr may not be used in STL containers that may perform element copies in their operations.
See also
[edit]References
[edit]- ^ "auto_ptr Class". Microsoft. Retrieved 2006-09-27.
- ^ Meyers, Scott (2014). Effective Modern C++: 42 specific ways to improve your use of C++11 and C++14. Sebastopol, CA. p. 118. ISBN 978-1-491-90399-5.
((cite book)): CS1 maint: location missing publisher (link) - ^ "Working Draft, Standard for Programming Language C++ N3242" (PDF). 28 February 2011. p. 1233. Retrieved 2013-02-17.
- ^ Kalev, Danny. "Using unique_ptr, Part I". informIT. Retrieved 30 September 2010.
- ^ "Programming Language C++, Library Evolution Working Group JTC1/SC22/WG21 N4190". 2014-10-09. Retrieved 2016-08-29.
- ^ "Collecting Shared Objects". Dr. Dobb's. 2004-07-01. Retrieved 2006-09-27.
External links
[edit]- Using
auto_ptreffectively - Avoiding Memory Leaks with
auto_ptr - Article "Using the
auto_ptrClass Template to Facilitate Dynamic Memory Management" by Danny Kalev - Article "Container of
auto_ptr" by Zeeshan Amjad - Article "Update on
auto_ptr" by Scott Meyers auto_ptrClass Template Reference from GNU libstdc++auto_ptrreference from Rogue Wave
| Features | |
|---|---|
| Standard Library | |
| Ideas | |
| Compilers | |
| IDEs | |
| Superset languages | |
| Dialects | |
| Relative to other languages | |
| Designer | |
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.
