re: multiple inheritance

re: multiple inheritance

["EDWARD CRAGG"]

Date: 19 Oct 89
From: crash!pro-novapple!herwin (Harry Erwin)
Subject:  Multiple Inheritance

Apparently there is some question about a requirement for multiple
inheritance in Ada 9X.  Multiple inheritance is necessary to support
generalized semantic data networks.  Although most problem domains are
simple enough that simple inheritance can be used with an appropriate
ordering of the object classes, the representation of domain knowledge
in some scientific fields is sufficiently convoluted that there is no
natural ordering, and multiple inheritance is a much more effective
solution to the problem of defining domain objects.  For similar reasons,
many intelligence processing applications are most effectively solved
by semantic data networks and (hence) multiple inheritance.  Omitting
multiple inheritance from Ada 9X will cripple it for those applications.

Harry Erwin
TELEMAIL: Herwin/TRW    UUCP: crash!pro-novapple!herwin
ARPA: crash!pro-novapple!herwin@nosc.mil
INTER: herwin@pro-novapple.cts.com

Re: Multiple Inheritance

[Guido van Rossum]

bs@alice.att.com (Bjarne Stroustrup) writes:

>MI in C++ and elsewhere isn't perfect and it isn't a panacea, but it works
>and it makes some styles of programming noticeably more convenient and
>less obscure. Naturally, it can also be overused and misused, but basically
>it works.

Point taken.  However, I still worry about MI.  When MI is *not* used,
it still imposes an overhead -- there is a "delta" offset in the vtbl
that is added to "this" each time a virtual function is called, but
this delta can only ever be nonzero when MI is used.  I feel that this
is in direct conflict with the C++ philosophy that language features
you don't use shouldn't cause overhead.

I am also still looking for examples of the styles of programming that
are aided by MI -- anyone got pointers?

--Guido van Rossum, CWI, Amsterdam <guido@cwi.nl>
"You can't do that in horizontal mode."

Re: Multiple Inheritance

[Pete Becker]

In article <4969@charon.cwi.nl> guido@cwi.nl (Guido van Rossum) writes:
>bs@alice.att.com (Bjarne Stroustrup) writes:
>
>>MI in C++ and elsewhere isn't perfect and it isn't a panacea, but it works
>>and it makes some styles of programming noticeably more convenient and
>>less obscure. Naturally, it can also be overused and misused, but basically
>>it works.
>
>Point taken.  However, I still worry about MI.  When MI is *not* used,
>it still imposes an overhead -- there is a "delta" offset in the vtbl
>that is added to "this" each time a virtual function is called, but
>this delta can only ever be nonzero when MI is used.  I feel that this
>is in direct conflict with the C++ philosophy that language features
>you don't use shouldn't cause overhead.
>

	That's an implementation issue, not a problem in the language
definition.  Those of us who have the luxury of being able to compile to
native code rather than C can easily avoid this problem.  Which is to say,
with our compiler, there is no MI-related overhead in any class that does
not use multiple inheritance.
	-- Pete

Re: Multiple Inheritance

[Larry M. Jordan]

Guido van Rossum writes:

>...However, I'm still worried about MI.  When MI is *not* used,
>it still imposes an overhead--there is a "delta" offset in the
>vtbl that is added to "this" each time a virtual function is called...

I own the Zortech C++ compiler and the documentation for it clearly
indicates there is *no* additional overhead if MI is *not* used.

Someone at Zortech want to confirm this?  

--Larry

Re: Multiple Inheritance

[Jim ADCOCK]

In article <4969@charon.cwi.nl> guido@cwi.nl (Guido van Rossum) writes:
|Point taken.  However, I still worry about MI.  When MI is *not* used,
|it still imposes an overhead -- there is a "delta" offset in the vtbl
|that is added to "this" each time a virtual function is called, but
|this delta can only ever be nonzero when MI is used.  I feel that this
|is in direct conflict with the C++ philosophy that language features
|you don't use shouldn't cause overhead.

This is not a language issue, but rather a "quality of implementation"
issue.  C++ compilers exist that don't require the delta in the vtable.