Re: Ada requires too much typing!

[Maciej Sobczak <see.my.homepage@gmail.com>]

On 6 Cze, 14:04, "Martin Krischik" <krisc...@users.sourceforge.net>
wrote:

> > I suppose there must be some cost to doing this? or the language
> > definition would require it to be always so.
>
> Yes indeed, you have virtual dispatch not only on the methods but on the  
> instance variables as well.

No, such concept does not even make sense - instance variables
themselves have no behavior and therefore cannot be "overriden". With
virtual inheritance there is only one copy of the given instance
variable within the whole object, so even the word "dispatch" cannot
be applied there, as "dispatch" relates to "choice" and there is no
choice.

> Main problem with multiple inheritance was in  C++ itself where default is  
> “fast” not ”save”.

No. Neither of these (non-virtual vs. virtual) is "fast" or "safe" in
itself.

Considering the performance aspect, the layout of variables within the
object is determined *statically* (I have already explained that there
is no "dispatch" involved), which means that there is no run-time cost
in finding the given data item. All instance variables have some
offset from the "beginning" of the object and that offset is computed
statically, whether inheritance is virtual or not. There is no
particular reason for any performance difference in data access, so it
does not make any sense to say than one mode is "fast", while the
other is not. Both are "fast" (it's C++, remember? ;-) ).

Considering the safety aspect, the choice between non-virtual and
virtual is design-dependent. Both make sense in some domain.
For example, my mobile phone is able to send both text and multimedia
messages. In both cases I might want to see the count of messages that
were already sent and I want these counters to be *distinct*, not
shared.
This is a perfectly valid design (pseudo-code):

class Countable;
class TextMessager : public Countable;
class MultimediaMessager : public Countable;
class Phone : public TextMessager, public MultimediaMessager, ...;

Now I have *separate* counters, both accessible with appropriate name
paths (which makes perfect sense).

Why is this a default? I don't know, but it's consistent with the fact
that the whole object model is value-oriented, not interface-oriented.
It's neither right nor wrong.

(note: you might argue that the counter should be held by composition,
not by extension - this is orthogonal to this discussion)

> but main problem stay: not enough C++ programmer have known about virtual  
> inheritance

Again, that knowledge would not necessarily help them, as the use of
virtual inheritance is not automatically justified.

> The real lesson learned: “doing it right” must be default

Both ways are right. The default one is consistent with the overall
object model.

> and “make it  
> fast” must be an optional extra

Both are fast.

--
Maciej Sobczak * http://www.inspirel.com

YAMI4 - Messaging Solution for Distributed Systems
http://www.inspirel.com/yami4