The auto_ptr class is defined so that, in most respects, it acts like a regular pointer. For example, given that ps
is an auto_ptr, you can dereference it (*ps), increment it (++ps), use it to access structure members (ps->puffIndex),
and assign it to a regular pointer that points to the same type.
The auto_ptr is not a panacea. For example, consider the following code:
auto_ptr<int> pi(new int ); // NO!
Remember, you must pair delete with new and delete  with new . The auto_ptr template uses delete, not delete ,
so it only can be used with new, not new . There is no auto_ptr equivalent for use with dynamic arrays. You could copy
the auto_ptr template from the memory header file, rename it auto_arr_ptr, and convert the copy to use delete  instead
of delete. In that case, you would want to add support for the  operator.
What about this?
string vacation("I wandered lonely as a cloud.");
auto_ptr<string> pvac(&vacation); // NO!
This would apply the delete operator to non-heap memory, which is wrong.
Caution: Use an auto_ptr object only for memory allocated by new, not for memory allocated by new or by simply declaring
Now consider assignment:
auto_ptr<string> ps (new string("I reigned lonely as a cloud."));
vocation = ps;
What should the assignment statement accomplish? If ps and vocation were ordinary pointers, the result would be two pointers
pointing to the same string object. That is not acceptable here, for then the program would wind up attempting to delete the same
object twice, once when ps expires, and once when vocation expires. There are ways to avoid this problem:
Define the assignment operator so that it makes a deep copy. This results in two pointers pointing to two distinct objects,
one of which is a copy of the other.
Institute the concept of ownership, with only one smart pointer allowed to own a particular object. Only if the smart pointer
owns the object will its constructor delete the object. Then have assignment transfer ownership. This is the strategy used for
Create an even smarter pointer that keeps track of how many smart pointers refer to a particular object. This is called
reference counting. Assignment, for example, would increase the count by one, and the expiration of a pointer would decrease
the count by one. Only when the final pointer expires would delete be invoked.
The same strategies, of course, would also be applied to the copy constructors.