Standard C++	Library
 		 Copyright 1996, Rogue Wave Software, Inc.

 NAME

   auto_ptr_  - A simple, smart pointer class.

 SYNOPSIS

   #include <memory>
   template <class X> class auto_ptr;

 DESCRIPTION

   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 if the source	had already had	ownership.

 INTERFACE

   template <class X> class auto_ptr {

     public:

        // constructor/copy/destroy

       explicit auto_ptr	(X* = 0) throw();
       template <class Y>
 	auto_ptr (const	auto_ptr<Y>&) throw();
       template <class Y>
 	void operator= (const auto_ptr<Y>&) throw();
        ~auto_ptr ();

        // members

       X& operator* () const throw();
       X* operator-> () const throw();
       X* get ()	const throw();
       X* release () throw();
    };

 CONSTRUCTORS AND DESTRUCTORS

   explicit
   auto_ptr (X* p = 0);
      Constructs	an object of class auto_ptr<X>,	initializing the  held
      pointer to	p, and acquiring ownership of that pointer.   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.

   template <class Y> auto_ptr (const auto_ptr<Y>& a);
      Copy constructor. Constructs an object of class auto_ptr<X>, and
      copies the argument a to *this.  If a owned the underlying
      pointer  then *this becomes the new owner of that pointer.

   ~auto_ptr ();
      Deletes the underlying pointer.

 OPERATORS

   template <class Y>
   void operator= (const	auto_ptr<Y>& a);
      Assignment	operator.  Copies the argument a to *this.  If	*this
      becomes the new owner of the underlying pointer. If a owned the
      underlying pointer then *this	becomes	the new	owner of that
      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.

 MEMBER FUNCTIONS

   X*
   get () const;
      Returns the underlying pointer.

   X*
   release();
      Releases ownership	of the underlying pointer.  Returns that
      pointer.

 EXAMPLE

      //
      //	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

 STANDARDS CONFORMANCE
   ANSI X3J16/ISO WG21 Joint C++	Committee