Re: Does object have function?

From:

James Kanze <james.kanze@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Mon, 1 Nov 2010 11:15:56 -0700 (PDT)

Message-ID:

<5f564302-8a2f-4604-b34c-2744da093ef3@k22g2000yqh.googlegroups.com>

On Oct 30, 9:56 am, "Bo Persson" <b...@gmb.dk> wrote:

Daniel T. 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.

It does need to have a distinct address from other objects of the same
type. For example, the empty base class optimization is not allowed if
the first member of the derived object is also of the base class'
type. Or there are two base classes of the same type.

That's the way I remember it, although I can't find the actual
wording to this effect off hand.

But whether the actual addresses are the same or not is
irrelevant. If you have something like:

    struct B1 { virtual ~B1(); };
    struct B2 { virtual ~B2(); };
    struct M1 : B2 {};
    struct M2 : B2 {};
    struct D : B1, M1, M2 {};

    B1* p1 = new D;
    B2* p2 = dynamic_cast<B2*>(p1);

the cast is required to fail. If the inheritance of B2 is
virtual in M1 and M2, it is required to succeed. Whether empty
base class optimization is present or not.

--
James Kanze