Re: Virtual inheritance
On Apr 30, 10:33 pm, "Massimo" <bar...@mclink.it> wrote:
"James Kanze" <james.ka...@gmail.com> ha scritto nel messaggionews:117792=
3207.412538.156160@q75g2000hsh.googlegroups.com...
On Apr 30, 3:53 am, "Massimo" <bar...@mclink.it> wrote:
Virtual inheritance only affects the classes which derive using
it.
Why is it in effect when I'm sub-deriving in a non-virtual manner, then?
I don't get what you're trying to say. If you write something
like:
class A : public B {} ;
B is NOT a virtual base. Period, and regardless of anything
else in the program. There will be one instance of B for every
instance of A, always.
On the other hand, all instances of all classes which
derive from Base will share a common instance.
You can't group, with two or three different groups of classes
sharing a common instance.
Yes, I've come to understand this.
Is the "virtual" keyword on sub-derivations redundant, then?
No. Either you inherit virtually, and the keyword is necessary,
or you don't inherit virtually, and the keyword cannot be used.
What you might try is making Base, the two DnBase and Middle
templates (without changing anything else), and instantiating
them on eithre D1Middle or D2Middle. By doing this, the 2
Middle, each of the DnBase, and the two Base are formally
different types.
This is a good suggestion; can you elaborate a bit? Specifically, what do
you mean by "instantiating"?
Do you know what a template is? Do you know what it means to
instantiate it.
Making DxMiddle a derived class of a
specialized Middle<T>? I think this wouldn't work; actually, before
semplifying it for posting, the real code involved Base, D1Base, D2Base a=
nd
Middle being template classes, and D1Middle being derived from
Middle<double>. D2Middle was derived from Middle<double> too, and the
purpose of D1Middle and D2Middle being different classes was exactly to be
able to derive (non-virtually!) Last from both of them, so having two
different Middle<double> inside a Last. But I'm stuck with undesidered
virtual inheritance, so members of D1Middle and D2Middle end un accessing
the same data.
The trick is to instantiate one side on D1Middle, and the other
on D2Middle.
Note that there's nothing in the rules which says that a
template has to use the instantiation type. Something like:
template< typename T >
class Base
{
// as before...
} ;
is perfectly legal. The class will behave exactly the same no
matter what type it is instantiated on, *but* it will have a
different type. Once you do this, you can then define the other
classes as:
template< typename T >
class D1Base : public virtual Base< T >
{
// as before...
} ;
template< typename T >
class D2Base : public virtual Base< T >
{
// as before...
} ;
template< typname T >
class Middle : public D1Base< T >, public D2Base< T >
{
// as before...
} ;
class D1Middle : public Middle< D1Middle >
{
// as before...
} ;
class D2Middle : public Middle< D2Middle >
{
// as before...
} ;
class Last : public D1Middle, public D2Middle
{
// as before...
} ;
This will result in the hierarchy you said you wanted, with the
exception that all of the classes on the left side will in fact
be instantiations on D1Middle, and all on the right side will in
fact be instantiations on D2Middle. (Note that this may affect
your external interface. There's no longer any such class a
Base, for example. And it typically means hoisting a lot of
code up into the headers---not necessarily something you want to
do either.)
--
James Kanze (Gabi Software) email: james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34