Re: Does object have function?
On Oct 29, 5:04 pm, "Daniel T." <danie...@earthlink.net> wrote:
Joshua Maurice <joshuamaur...@gmail.com> wrote:
On Oct 29, 4:46 am, "Daniel T." <danie...@earthlink.net> wrote:
Joshua Maurice <joshuamaur...@gmail.com> wrote:
With this multiple inheritance design, I would guess that you
probably want to virtually inherit from Fooer as well (not done in
the above code).
Virtual inheritance would only be necessary if Fooer had
member-variables. Inheriting interfaces (classes with only pure
virtual functions and no member-variables,) does not require virtual
inheritance.
I'm not so sure about this. Let me think about it.
At the very least, if you inherit from such an "interface" class
twice, then you will have two distinct base class sub-objects, and
they will have distinct addresses. (IIRC, the intent of the standard
is that two objects (complete or sub-objects) of the same type should
be distinct objects iff they have distinct addresses. However, I
recall that the wording might have been changed to remove this
requirement. Not sure what the situation is.) I would think that that
is counter-intuitive. I think that a programmer might simply assume
that if he has two distinct Fooer (sub)objects (distinct according to
distinct addresses), then he has two distinct complete objects.
However, such inference would be incorrect without virtual inheritance.
The empty base class optimization means that the above is not the case.
A base class that contains no data members need not have a distinct
address.
In any case, virtual inheritance only comes into play if there is a
diamond inheritance pattern, which there is not in this example.
IIRC, there was a thread on exactly this topic in the last year. I
think the discussion revolved around whether it was legal, and how the
wording of the standard was changed in one revision to maybe make it
legal.
Let's take the following case:
struct A {};
struct B : A {};
struct C : A {};
struct D : B, C {};
With my rule that two objects of the same type have the same address
iff they're the same object, then you still are allowed to do empty
base class optimization, just not all of it. Ex:
D * d = new D;
C * c = d;
A * ca = c;
B * b = d;
A * ba = b;
bool cmp_ptr(void* x, void* y) { return x == y; }
In that example, d, b, and ba may all compare equal by cmp_ptr. The
empty base class optimization could legally make B object and the A
base class sub-object of B ccupy the same byte, and it could again
make the D object and B base class sub-object occupy the same might.
It could then do the same for C and C's A. However, it could not do it
again for D and C. If it did that, then B's A and C's A would have the
same address, and that would not be allowed.
At least, one version of the standard read that way, and I think a
different version removed that restriction. Can anyone help me out
here?