Cloning revisited

Now that most (all?) common compilers support covariant routines it has become
much simpler to avoid the tedious manual implementation of cloning in each class.

Here's my take:

<code>
#include <memory>
#include <typeinfo>
#include <assert.h>

#define IMPLEMENT_CLONING( Class ) \
     virtual Class* virtualClone() const \
     { \
         assert( typeid( *this ) == typeid( Class ) ); \
         return new Class( *this ); \
     } \
                                                                     \
     std::auto_ptr<Class> clone() const \
     { \
         return std::auto_ptr<Class>( virtualClone() ); \
     }
</code>

The 'virtualClone' is not mean to be used directly, and I considered whether to
make it difficult to use it directly. But this is perhaps a case where the FAQ's
advice that a stern comment about not doing something often suffices, is spot
on? Anyway, after first trying a scheme of inheriting cloning via templated
classes, based on dominance in an inheritance chain from a topmost virtual base
class (it got ugly, three compilers reported three very different reasons why
they couldn't accept it, and I can't even find a word about dominance in the
Holy Standard!), I finally followed the KISS principle: Keep It Simple, Stupid!

Cheers,

- Alf