Login
Login

Auto ptr

{{DISPLAYTITLE:auto_ptr}}

{{short description|Deprecated class of smart pointers in C++}}

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 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.{{cite web |url=http://msdn2.microsoft.com/en-us/library/ew3fk483.aspx |publisher=Microsoft |title=auto_ptr Class |accessdate=2006-09-27}}

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.{{cite book |last1=Meyers |first1=Scott |title=Effective Modern C++: 42 specific ways to improve your use of C++11 and C++14 |date=2014 |location=Sebastopol, CA |isbn=978-1-491-90399-5 |page=118}}

The C++11 standard made auto_ptr deprecated, replacing it with the unique_ptr class template.{{cite web

|title=Working Draft, Standard for Programming Language C++ N3242

|url=http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf

|accessdate=2013-02-17|page=1233|date=28 February 2011}}{{cite web|last=Kalev

|first=Danny|title=Using unique_ptr, Part I|url=http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=400|publisher=informIT|accessdate=30 September 2010}} auto_ptr was fully removed in C++17.{{cite web

|title=Programming Language C++, Library Evolution Working Group JTC1/SC22/WG21 N4190

|url=http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4190.htm

|accessdate=2016-08-29|date=2014-10-09}}

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.{{cite web |url=http://www.ddj.com/dept/cpp/184401839 |publisher=Dr. Dobb's |title=Collecting Shared Objects |date=2004-07-01 |accessdate=2006-09-27}}

Declaration

The auto_ptr class is declared in ISO/IEC 14882, section 20.4.5 as:

namespace std {

template struct auto_ptr_ref {};

template

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 auto_ptr(auto_ptr&) throw();

auto_ptr& operator=(auto_ptr&) throw();

template auto_ptr& operator=(auto_ptr&) throw();

auto_ptr& operator=(auto_ptr_ref) 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) throw();

template operator auto_ptr_ref() throw();

template operator auto_ptr() throw();

};

}

Semantics

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:

  1. include
  2. include

using namespace std;

int main(int argc, char **argv)

{

int *i = new int;

auto_ptr x(i);

auto_ptr 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

References

{{Reflist}}

External links

  • [http://www.gotw.ca/publications/using_auto_ptr_effectively.htm Using auto_ptr effectively]
  • [http://cprogramming.com/tutorial/auto_ptr.html Avoiding Memory Leaks with auto_ptr]
  • Article "[https://web.archive.org/web/20080306193914/http://gethelp.devx.com/techtips/cpp_pro/10min/10min1199.asp Using the auto_ptr Class Template to Facilitate Dynamic Memory Management]" by Danny Kalev
  • Article "[http://www.codeproject.com/Articles/5222/Container-of-auto-ptr Container of auto_ptr]" by Zeeshan Amjad
  • Article "[http://www.aristeia.com/BookErrata/auto_ptr-update.html Update on auto_ptr]" by Scott Meyers
  • [https://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.0/classstd_1_1auto__ptr.html auto_ptr Class Template Reference from GNU libstdc++]
  • [https://web.archive.org/web/20110928163834/http://www.roguewave.com/Portals/0/products/legacy-hpp/docs/stdref/auto-ptr.html auto_ptr reference from Rogue Wave]

{{C++ programming language}}

Category:Articles with example C++ code

Category:Articles with underscores in the title

Category:C++ Standard Library