Related Searches


Auto ptr

auto_ptr is a template class available in the C++ Standard Library (declared in ) that provides some basic RAII features for C++ raw pointers.

The auto_ptr template class describes an object that stores a pointer to an allocated object of type Type* that ensures that the object to which it points gets destroyed automatically when control leaves a scope.

The shared_ptr template class proposed in Technical Report 1 and available in the Boost library can be used as an alternative to auto_ptr for collections with ownership semantics.


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

template struct auto_ptr_ref {};

   class auto_ptr {
       typedef X element_type;

       // 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 r) throw();

       ~auto_ptr() throw();

       // members:
       X&     operator*() const throw();
       X*     operator->() const throw();
       X*     get() const throw();
       X*     release() throw();
       void   reset(X* p =0) throw();

       // conversions:
                                  auto_ptr(auto_ptr_ref) throw();
       template  operator auto_ptr_ref() throw();
       template  operator auto_ptr() throw();



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

using namespace std;

int *i = new int; auto_ptr x(i); auto_ptr y;

y = x;

cout << x.get() << endl; cout << y.get() << endl; 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.

Notice that the object pointed by an auto_ptr is destructed 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 operator new[].

See also


External links

Search another word or see coapon Dictionary | Thesaurus |Spanish
Copyright © 2015, LLC. All rights reserved.
  • Please Login or Sign Up to use the Recent Searches feature