Re: Merits of re-dispatching [LONG]

[dmitry@elros.cbb-automation.de (Dmitry A. Kazakov)]

On Wed, 13 Feb 2002 19:58 +0000 (GMT Standard Time),
brangdon@cix.co.uk (Dave Harris) wrote:

>dmitry@elros.cbb-automation.de (Dmitry A. Kazakov) wrote (abridged):
>> That is one of several possible interpretation of what happens in C++
>> using Ada terms. However, I prefer mine, because it is consistent with
>> the fact that the type tag [= vtab] is constant, thus the actual
>> specific type is also constant.
>> [...]
>> When you pass it to some other routine an implicit specific->class
>> wide conversion happens, so the routine can dispatch again.
>
>This doesn't work. If you look at the 3 calls to call_foo() in Hyman 
>Rosen's example, you'll see it dispatches to 3 different places. Therefore 
>we cannot view the object has having a constant type with 2 kinds of 
>dispatching. A specific->class-wide conversion would have it printing 
>C::foo 2 or 3 times. Your view doesn't match the visible behaviour.
>
>If you think in terms of a conversion, the different calls to call_foo() 
>must convert to different types. It's not enough to switch the vtable on 
>and off, you need different conceptual vtables.

Yes. C has a tag, B in C has another and A in B in C has the third.
This is why I do not like embedded tags.

>Given this, its simpler to think of the conversion as happening as soon as 
>the constructor is entered, rather than when the constructor calls out.

Surely. There is a type conversion, but it is an "in-place"
conversion. It changes neither the object C nor its type. It only
shifts the reference to C.B.

>> An Ada 95 equivalent would be:
>
>Your example only shows 2 types, so doesn't capture the richness of 
>behaviour of Hyman's example which has 3. I suspect you have misunderstood 
>it.

That there are three types changes nothing. It works pretty well in
Ada 95:

type A is ...
procedure Foo (Object : A) is
begin
   Put_Line ("A.Foo");
end Foo;
procedure Finalize (Object : in out A) is
begin
   Foo (Object);            -- No dispatch here, A.Foo is called
end Finalize;
--------------------
type B is new A ...
procedure Foo (Object : B) is
begin
   Put_Line ("B.Foo");
end Foo;
procedure Finalize (Object : in out B) is
begin
   Foo (Object);            -- No dispatch here, B.Foo is called
   Finalize (A (Object)); -- C++ adds this automatically
end Finalize;
---------------------------
type C is new B...
procedure Foo (Object : C) is
begin
   Put_Line ("C.Foo");
end Foo;
procedure Finalize (Object : in out C) is
begin
   Foo (Object);            -- No dispatch here, C.Foo is called
   Finalize (B (Object)); -- C++ adds this automatically
end Finalize;

When C is finalized, then C.Foo, B.Foo, A.Foo will be printed.

Regards,
Dmitry Kazakov