Using an auto_ptr
The auto_ptr template defines a pointer-like object intended to be assigned an address obtained (directly or indirectly) by new.
When an auto_ptr object expires, its destructor uses delete to free the memory. Thus, if you assign an address returned by new to
an auto_ptr object, you don't have to remember to free the memory later; it will be freed automatically when the auto_ptr object
expires. The auto_ptr is an example of a smart pointer, an object that acts like a pointer, but with additional features. The auto_ptr
class is defined so that, in most respects, it acts like a regular pointer.
auto_ptr Considerations
The auto_ptr is not a panacea. For example, consider the following code:
auto_ptr<int> pi(new int [200]); // 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 a variable.
Now consider assignment:
auto_ptr<string> ps (new string("I reigned lonely as a cloud."));
auto_ptr<string> vocation;
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 auto_ptr.
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.
Smart Pointers
The C++ library auto_ptr is an example of a smart pointer. A smart pointer is a class designed so that objects of that class have pointer-like
properties. For example, a smart pointer can store the address of memory allocated by new and can be dereferenced. Because a smart pointer is
a class object, it can modify and augment the behavior of a simple pointer. For instance, a smart pointer can institute reference counting. This
allows several objects to share a single representation of a value tracked by a smart pointer. When the number of objects using the value drops to
zero, the smart pointer can then delete the value. Smart pointers can allow for more efficient use of memory and help prevent memory leaks, but
they do require the user to become familiar with new programming techniques.