Standard C++ LibraryCopyright 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



privacy and legal statement