scoped_ptr class template

The scoped_ptr class template stores a pointer to a dynamically allocated
object. (Dynamically allocated objects are allocated with the C++ new expression.)
The object pointed to is guaranteed to be deleted, either on destruction of the scoped_ptr,
or via an explicit reset. See the example.

The scoped_ptr template is a simple solution for simple needs. It
supplies a basic "resource acquisition is initialization" facility, without
shared-ownership or transfer-of-ownership semantics. Both its name and
enforcement of semantics (by being
noncopyable) signal its intent to retain ownership solely within the
current scope. Because it is noncopyable,
it is safer than shared_ptr or std::auto_ptr for pointers which
should not be copied.

Because scoped_ptr is simple, in its usual implementation every operation
is as fast as for a built-in pointer and it has no more space overhead that a
built-in pointer.

scoped_ptr cannot be used in C++ Standard Library containers.
Use shared_ptr if you need a smart pointer
that can.

scoped_ptr cannot correctly hold a pointer to a dynamically
allocated array. See scoped_array for
that usage.

The class template is parameterized on T, the type of the object pointed
to. T must meet the smart pointer
common requirements.

Deletes the object pointed to by the stored pointer and then stores a copy of
p, which must have been allocated via a C++ new expression or be 0. The
guarantee that this does not throw exceptions depends on the requirement that
the deleted object's destructor does not throw exceptions. See the smart
pointer common requirements.

The example program produces the beginning of a child's nursery rhyme:

1
2
Buckle my shoe

Rationale

The primary reason to use scoped_ptr rather than auto_ptr is to
let readers of your code know that you intend "resource acquisition is
initialization" to be applied only for the current scope, and have no intent to
transfer ownership.

A secondary reason to use scoped_ptr is to prevent a later maintenance
programmer from adding a function that transfers ownership by returning the auto_ptr,
because the maintenance programmer saw auto_ptr, and assumed ownership
could safely be transferred.

Think of bool vs int. We all know that under the covers bool
is usually just an int. Indeed, some argued against including bool
in the C++ standard because of that. But by coding bool rather than int,
you tell your readers what your intent is. Same with scoped_ptr; by
using it you are signaling intent.

It has been suggested that scoped_ptr<T> is equivalent to std::auto_ptr<T>
const. Ed Brey pointed out, however, that reset will not work on
a std::auto_ptr<T> const.

Frequently Asked Questions

Q. Why doesn't scoped_ptr have a release() member?A. When reading source code, it is valuable to be able to draw
conclusions about program behavior based on the types being used. If scoped_ptr
had a release() member, it would become possible to transfer ownership of the
held pointer, weakening its role as a way of limiting resource lifetime to a
given context. Use std::auto_ptr where transfer of ownership
is required. (supplied by Dave Abrahams)