Library: General utilities
Does not inherit
|
auto_ptr() auto_ptr_ref element_type |
get() operator auto_ptr<Y>() operator auto_ptr_ref<Y>() |
operator*() operator->() operator=() |
release() reset() ~auto_ptr() |
A simple smart pointer class
#include <memory>
namespace std {
template <class X> class auto_ptr;
}
The class template specialization auto_ptr holds onto a pointer obtained via new() and then deletes that object when the auto_ptr object itself is destroyed. auto_ptr can be used to make calls to operator new() exception-safe. The auto_ptr class has 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.
namespace std {
template <class Y> struct auto_ptr_ref {};
template <class X> class auto_ptr {
public:
typedef X element_type;
// construct/copy/destroy
explicit auto_ptr (X* p = 0) throw();
auto_ptr(auto_ptr<X>&) throw ();
template <class Y>
auto_ptr(auto_ptr<Y>&) throw();
auto_ptr<X>& operator=(auto_ptr<X>&) throw();
template <class Y>
auto_ptr<X>& operator= (auto_ptr<Y>&) 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<X>) throw();
template <class Y> operator auto_ptr_ref<Y>() throw();
template <class Y> operator auto_ptr<Y>() throw();
};
}
template <class Y> struct auto_ptr_ref;
A namespace-scope struct template that holds a reference to an auto_ptr. An auto_ptr_ref can only be constructed within an auto_ptr using a reference to an auto_ptr. It prevents unsafe copying.
typedef X element_type;
The type of element pointed to by auto_ptr.
explicit auto_ptr (X* p = 0) throw();
Constructs an object of class auto_ptr<X>, initializing the held pointer to p, and acquiring ownership of that pointer. p must point to an object of class X, a class derived from X for which delete p is defined and accessible, or p must be a null pointer.
auto_ptr (auto_ptr<X>& a) throw(); template <class Y> auto_ptr (auto_ptr<Y>& a) throw();
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.
For the constructor template, each specialization requires that a pointer to Y be implicitly convertible to pointer to element_type.
auto_ptr (auto_ptr_ref<X> r) throw();
Constructs an auto_ptr from an auto_ptr_ref.
~auto_ptr () throw();
Deletes the underlying pointer.
auto_ptr<X>& operator=(auto_ptr<X>& a) throw(); template <class Y> auto_ptr<X>& operator=(auto_ptr<Y>& a) throw();
Copies the argument a to *this. If a owned the underlying pointer, then *this becomes the new owner of that pointer. If *this already owned a pointer, that pointer is deleted first. The argument a is reset to zero.
For the function template, each specialization requires that a pointer to Y be implicitly convertible to pointer to element_type.
X& operator*() const throw();
Returns a reference to the object to which the underlying pointer points.
X* operator->() const throw();
Returns the underlying pointer.
template <class Y> operator auto_ptr_ref<Y>() throw();
Constructs an auto_ptr_ref from *this and returns it.
template <class Y> operator auto_ptr<Y>() throw();
Constructs a new auto_ptr using the underlying pointer held by *this. Calls release() on *this, so *this no longer possesses the pointer. Returns the new auto_ptr.
X* get() const throw();
Returns the underlying pointer.
X* release() throw();
Releases ownership of the underlying pointer and returns that pointer. The *this object is left holding a null pointer.
void reset(X* p = 0) throw();
Sets the underlying pointer to p. If non-null, deletes the old underlying pointer.
//
// auto_ptr.cpp
//
#include <iostream> // for cout, endl
#include <memory> // for auto_ptr
// A simple structure.
class X
{
int i_;
public:
X (int i) : i_ (i) {
std::cout << "X::X (" << i_ << ')' << std::endl;
}
~X () {
std::cout << "X::~X [" << i_ << ']' << std::endl;
}
int get () const { return i_; }
};
int main ()
{
// a implicitly initialized to 0 (the null pointer)
std::auto_ptr<X> a;
// Establish a scope.
if (1) {
// b will hold a pointer to an X.
std::auto_ptr<X> b (new X (12345));
// a will now be the owner of
// the underlying pointer.
a = b;
}
std::cout << "b destroyed" << std::endl;
// Output the value contained by
// the underlying pointer.
#ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN
std::cout << a->get () << std::endl;
#else
std::cout << (*a).get () << std::endl;
#endif
// The pointer will be deleted when a is destroyed
// on leaving scope.
return 0;
}
Program Output:
X::X (12345)
b destroyed
12345
X::~X [12345]
ISO/IEC 14882:1998 -- International Standard for Information Systems -- Programming Language C++, Section 20.4.5