Re: Virtual constructor?
Vladimir Marko wrote:
kanze wrote:
ThosRTanner wrote:
[...]
Isn't this one of those places where you use the Curiously
Recurring Template pattern
template <class C> cloneable { virtual C* clone() return new C(*this) }
and then do
struct B : public A, cloneable<B> { .... }
One can, although it would more likely be something like:
template< typename Derived, typename Base >
class Clonable : public Base
{
virtual Base* clone() const
{
return new Derived( *dynamic_cast< Derived const* >( this )
) ;
}
} ;
class B : public Clonable< B, A > ...
Otherwise, the function clone in the template won't override
the function clone in the base class.
Why dynamic_cast when static_cast is sufficient?
Because I'm not perfect, and neither are my users. Some sort of
verification is necessary, for cases where someone accidentally
writes:
class D1 : public Clonable< D2, B > ...
(This sort of thing happens to me a lot; very often, the derived
classes contain a significant amount of boilerplate code --
forwarding constructors, and so on. So I start with a
copy/paste of an existing derived class, and forget to edit the
template parameters.)
Starting from scratch, today, I think I'd look into some sort of
static check, Boost's static assert, or something along those
lines -- it's not difficult to verify statically in Clonable
that Derived derives from Clonable< Derived >.
You can't use this for virtual inheritance anyway:
class B{ ... };
class B1: virtual public Clonable<B1,B> { ... };
class B2: virtual public Clonable<B2,B> { ... };
class D: public Clonable2<D,B1, B2> { ... };
// D contains _two_ subobjects of class B
Obviously, in a production version, you'd inherit virtually in
the template clonable, to avoid this problem. Or you'd have two
versions of Clonable, one with direcct virtual inheritance, and
another with direct non-virtual inheritance, and virtual
inheritance of AbstractClonable.
You'd need to add some traits to the template parameters for
Clonable to indicate the type of inheritance
(public/private/protected, normal/virtual). And, of course, to
ClonableX for multiple inheritance.
For example. A lot depends on your application; writing a
single, totally generic Clonable which covers all cases is
probably possible, but certainly a lot of work, probably most of
which won't be needed.
The other problem is the return type of the clone function.
Ideally it should be Derived*, but this is not possible.
Normally, I disagree; I've never had a case where just returning
Base* everywhere caused any problems. But if you do want for
clone in the derived clonable to return Derived*, then the
Barton and Nackman trick of using a non-virtual function (here
clone) in the base class, and hiding it in all of the derived
classes, does. Of course, it doesn't extend very well to N
layers of inheritance, but then, what does?
There's been a thread in clc++m in late 2004 where I suggested
the following:
// WARNING: THIS DOES NOT WORK
template <class Derived,class Base>
struct Clonable: Base {
virtual Derived* clone() const{
return new Derived(static_cast<const Derived&>(*this));
}
};
struct B { virtual B* clone() const =0; virtual ~B(); };
struct D: Clonable<D,B> { };
The idea is that the Clonable<D,B>::clone's result type would
be D* which is covariant with B*. A few months later someone
asked about this again and I discovered that it can't work.
The problem is that during the _instantiation_ of the
_declaration_ of Clonable<D,B>::clone D is still an incomplete
type and the base-derived relation between D and B doesn't
exist yet.
Interesting. A subtle problem; I'll admit that it wouldn't have
occured to me.
In the end it seems that writing the clone function manually
is the best option.
Well, it seems simple enough to me to not be worth the bother of
doing it otherwise. But others seem to disagree.
--
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! ]