I thought it might be useful to explain a little more of the reason why auto_ptr was included in the standard. (There was a great deal of haggling about this and other types of pointer wrappers, and there are a number of other pointer wrappers in boost (boost.org) that will almost certainly make it into the next version of the standard.) The reason why auto_ptr is important relates to exceptions. Consider this: class excep { /* some exception class */}; void g() { try { f(); } catch(excep &e) { handle(e); } } void f() { int* a = new int; *a = might_throw_excep(); other_fn(); delete a; }; Now consider what happens if might_throw_excep throws an exception. In that case, the stack unwinds to the nearest matching catch statement (in g), but that means that a, which is now out of scope, points to heap allocated memory that will never be deleted. auto_ptr solves this problem, by rewriting f() as the following: void f() { auto_ptr a = new int; *a = might_throw_excep(); other_fn(); } In this case, the destructor of a (which is an auto_ptr template class) is called when it goes out of scope. This causes the object a to be deleted. However, what is more important is this: even if might_throw_excep throws, then as part of the exception processing system, the destructors of the classes are called as the stack is unwound to the catch statement. This happens even though other_fn is not called. That means that, even if an exception is thrown, a's destructor is called, and it doesn't leak memory. For that reason, auto_ptr (or something like it) is necessary to write leak free code in the presence of exceptions. This is the motivation, AFAIK, behind why auto_ptr was added to the standard. HTH.
