Automatically create a clone() function for derived classes

  I'm sure this is a frequently asked question, but...

  Suppose that I have a hierarchy of objects which are typically
allocated dynamically and handled with some smart pointer or whatever.
However, I want to be able to create copies of those objects, while
having only a pointer-to-base-class. The solution is to write a clone()
member function like this:

class Base
{
 public:
    virtual Base* clone() const { return new Base(*this); }

    // other stuff here
};

  The problem is that this clone() function must be replicated in all
the derived classes as well, and their implementation is always the
same, except for the type which is being allocated. For example:

class Derived: public Base
{
 public:
    virtual Base* clone() const { return new Derived(*this); }
};

  It's not only tedious to have to write this line in each of the
derived classes, but it's also error-prone: If you ever forget to add
that line to some derived class, no compiler error will happen, and the
program will even run, but when cloning a derived object using a base
type pointer, you get a crippled copy, so the whole thing malfunctions,
and it might malfunction in a very non-obvious way which is hard to
track and debug.

  Isn't there any way of automating this process? (And without making
the base class a template class, which would be rather tedious if the
base class is large, especially since we don't have export templates in
practice.)