As a rule, you should never use std::auto_ptr. It is deprecated. A single copy or assignment operation can render the source object unusable.

The following: operator* and operator->. They help use objects of the class with regular pointer semantics.

Probably you wouldn't because of the cyclic dependency that will keep the reference count from going down to zero and will consequently keep objects of the two classes permanently in the heap.

No, it isn't. These classes typically don't implement both operator* and operator-> and are therefore not classifiable as smart pointers.

If your code or module needs to only be reading from a file, you should instead use ifstream. Similarly, if it needs to only write to a file use ofstream. In both cases fstream would work fine, but for the sake of ensuring data and code integrity, it is better to have a restrictive policy similar to using const, which is not compulsory either.

cin.getline() ensures that you capture the entire line including white spaces entered by the user. cin.get()helps you capture user input one character at a time.

You may not always have the privilege of returning an error. If a call to new fails, you need to handle exceptions thrown by new to prevent your application from crashing. Additionally, if an error is very severe and makes the future functioning of your application impossible, you should consider throwing an exception.

This is, of course, not compulsory, but it helps you reuse all those catch() blocks that already catch exceptions of type std::exception. You can write your own exception class that doesn’t inherit from anything else, but then you have to insert new catch(MyNewExceptionType&) statements at all the relevant points.

Not at all. Just ensure that the exception type thrown is caught at one of the calling functions in the call stack.

Constructors actually have no choice! They don't have return values, and throwing an exception is the best way to demonstrate disagreement.