auto_ptr

     Memory Management

A simple, smart pointer class.

Contents

• Synopsis
• Description
• Interface
• Constructors and Destructors
• Operators
• Member Functions
• Example

#include <memory>

template <class X> class auto_ptr;

The template class auto_ptr holds onto a pointer obtained via new and deletes that object when the auto_ptr object itself is destroyed (such as when leaving block scope). auto_ptr can be used to make calls to operator new exception-safe. The auto_ptr class provides semantics of strict ownership: an object may be safely pointed to by only one auto_ptr, so copying an auto_ptr copies the pointer and transfers ownership to the destination.

template <class X> class auto_ptr {

   public:
     // constructor/copy/destroy
     explicit auto_ptr (X* = 0);
     auto_ptr (const auto_ptr<X>&);
     void operator= (const auto_ptr<X>&);
     ~auto_ptr ();
     // members
     X& operator* () const;
     X* operator-> () const;
     X* get () const;
     X* release ();
     void reset (X* = 0);
 };

explicit 
auto_ptr (X* p = 0);

Constructs an object of class auto_ptr<X>, initializing the held pointer to p. Requires that p points to an object of class X or a class derived from X for which delete p is defined and accessible, or that p is a null pointer.

auto_ptr (const auto_ptr<X>& a);

Copy constructor. Constructs an object of class auto_ptr<X>, and copies the argument a to *this. *this becomes the new owner of the underlying pointer.

~auto_ptr ();

Deletes the underlying pointer.

void 
operator= (const auto_ptr<X>& a);

Assignment operator. Copies the argument a to *this. *this becomes the new owner of the underlying pointer. If *this already owned a pointer, then that pointer is deleted first.

X& 
operator* () const;

Returns a reference to the object to which the underlying pointer points.

X* 
operator-> () const;

Returns the underlying pointer.

X* 
get () const;

Returns the underlying pointer.

X*
release();

Releases ownership of the underlying pointer. Returns that pointer.

void 
reset (X* p = 0);

Requires that p points to an object of class X or a class derived from X for which delete p is defined and accessible, or p is a null pointer. Deletes the current underlying pointer, then resets it to p.

   //
   // auto_ptr.cpp
   //
   #include <iostream.h>
   #include <memory>
   //
   // A simple structure.
   //
   struct X
   {
       X (int i = 0) : m_i(i) { }
       int get() const { return m_i; }
       int m_i;
   };
   int main ()
   {
      //
      // b will hold a pointer to an X.
      //
      auto_ptr<X> b(new X(12345));
      //
      // a will now be the owner of the underlying pointer.
      //
      auto_ptr<X> a = b;
      //
      // Output the value contained by the underlying pointer.
      //
      cout << a->get() << endl;
      //
      // The pointer will be deleted when a is destroyed on 
      // leaving scope.
      //
      return 0;
   }
Output : 
12345