Re: Virtual constructor?
Alf P. Steinbach wrote:
* Wu Yongwei:
James Kanze wrote:
Wu Yongwei wrote:
Derived* clone() const
{
if (typeid(Derived) == typeid(*this))
return new Derived(*static_cast<const Derived*>(this));
else
return static_cast<Derived*>(doClone());
}
Any comments?
What's wrong with just:
Derived* clone() const
{
Derived* result = doClone() ;
assert( typeid( *result ) == typeid( *this ) ) ;
return result ;
}
// ...
Derived* doClone() const
{
return new Derived( *dynamic_cast< Derived const* >( this ) ) ;
}
Nothing wrong: it is better (though clone() is now always
virtual; but it is always virtual in Java too).
Huh? dynamic_cast to pointer type doesn't throw an exception
on failure, it produces a nullpointer. Dereferencing that
nullpointer & accessing the result, as is potentially done in
doClone, is very UB.
Good point. In this particular case, we are safe IF the class
is used correctly (and compile time asserts can be used to
ensure that it is used correctly), but it's a bad habit to get
into.
I haven't followed the thread but also what I see of the
original code above, looks very wrong/unsafe.
Well, the code is (or was meant to be) part of a template class:
template< typename Derived, typename Base >
class Clonable : public Base
{
// ...
} ;
which is intended to be used:
class MyDerived : public Clonable< MyDerived, MyBase > { ... } ;
The class Clonable should have some sort of concept check to
ensure that it is only used as a base class to Derived, but I'm
not sure how to implement this. It's easy to check that Derived
really does derived from Clonable< Derived, Base >, but the most
frequent cause of error is probably due to using copy/paste to
create a SecondDerived from MyDerived, and forgetting to correct
the name in the template instantiation.
So you're definitly right: it should be:
Derived*
doClone() const
{
Derived const* tmp
= dynamic_cast< Derived const* >(this ) ;
assert( tmp != NULL ) ;
return new Derived( *tmp ) ;
}
Cloning is a typical example of the sort of problem --
repeated glue & pattern code -- that templates were supposed
to help with, but don't, really. We have the same with
visitor pattern (which I think is much more important than
cloning, but both are important). We need Andrei, or someone,
to come up with a brilliant solution.
Some sort of concept check that Clonable< Derived, Base > is not
used other than as an immediate base of Derived would be what
the doctor ordered here. But off hand, I don't know how to do
it. And what can you do in Base to prevent Derived from
deriving directly from Base, without an intermediate Clonable?
I might add that I did the above more as an intellectual
exercise than as a potential pragmatic solution. Unless you
really can somehow impose that the correct instantiation of
Clonable is a direct base of all of the classes in the
hierarchy, and make it work with all of the configurations of
multiple inheritance, it just gives a false sense of security.
And doing all that is probably a lot more work than it is worth.
My experience has been that people don't forget to override
clone() when they're supposed to, and that if they do, code
review will certainly catch it. Adding a run-time check in the
base class is already at the limit as to the amount of work
worth investing for error catching here, and anything more is
too much.
--
James Kanze GABI Software
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]