Re: Virtual constructor?
godfat@gmail.com wrote:
Gene Bushuyev wrote:
The problem with using CRTP is that it introduces ambiguity
due to multiple inheritance, rather than overriding the
virtual clone() function.
That's only a problem if you are doing it incorrectly.
(ThosRTanner admitted that "I haven't used the pattern that much
but I think it works something like that.")
I'm not sure of the exact limits of the term CRTP, but what is
wanted here is a class template which is inserted between the
most derived class and its immediate base, not along side of it.
Here is an example,
template <class C>
class cloneable
{
public:
virtual C* clone() const { return new C(*this); }
};
class A : public cloneable<A> { public: A(const A&); A();};
class B : public A, public cloneable<B>
{ public: B(const B&); B();};
int main()
{
B* b = new B;
B* c = b->clone();
}
compiler cannot resolve the ambiguity between
cloneable<A>::clone() and cloneable<B>::clone().
There are several different problems here. First, of course, is
that the base of the hierarchy wouldn't normally be a template,
and wouldn't derive from the Clonable template. In fact, no
abstract class can derive from the Clonable template; since
clone is a virtual function, it is considered "used" anytime an
instance of the class is constructed. And because it is used,
it will be instantiated, and the instantiation of the clone
function will fail because it attempts to instantiate an object
with a type of an abstract class.
I don't know if this would work, and somehow I got different
error messages from compiler to compiler.
template <class T>
class cloner{
protected:
T* clone() const{ return new T(*static_cast<T const*>(this)); }
cloner(){}
};
struct null_type{};
template <class T, class Parent = null_type>
struct cloneable: public Parent, private cloner<T>{
virtual T* clone() const{ return cloner<T>::clone(); }
// ^^^ note here
};
I can't figure out what you're trying to do here.
I've indicated the standard idiom in another posting. It can
easily be modified to support both programming by contract and
(pseudo-)co-variant returns, something like:
template< typename Derived, typename Base >
class Clonable : public Base
{
public:
Derived* clone() const
{
return new Derived(
*dynamic_cast< Derived const* >( this ) ) ;
}
private:
virtual Base* doClone() const
{
return clone() ;
}
} ;
template< typename Base >
class AbstractClonable
{
public:
AbstractClonable* clone() const
{
Base* result = doClone() ;
assert( typeid( result ) == typeid( *this ) ) ;
return result ;
}
private:
virtual Base* doClone() const = 0 ;
} ;
If you really want to use the same name for both classes, you'll
have to define some dummy type, make it the default parameter
for Base in Clonable, and then provide a partial specialization
for the case where it is the parameter for Base, which does what
AbstractClonable does above.
--
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! ]