Re: Question about OO programming in Ada

[Dmitry A. Kazakov <mailbox@dmitry-kazakov.de>]

On Tue, 09 Dec 2003 08:29:16 -0500, Hyman Rosen <hyrosen@mail.com>
wrote:

>Dmitry A. Kazakov wrote:
>> Dispatch table is a property of a dispatching subroutine.
>
>No it's not, at least not in the nearly universal C++ implementation.
>In that approach, there exists one dispatch table per tagged class
>with slots for each virtual function of that class. Then every object
>of that class contains a pointer to this single dispatch table. To
>make a dispatching call, the compiler accesses the dispatch table
>using the index corresponding to the function being called, and calls
>the method found there. (The model is more complicated due to virtual
>and multiple inheritance, so that an object may contain pointers to
>more than one dispatch table, and the addresses are sometimes to fixup
>thunks, but that doesn't matter here.)
>
>I'm pretty sure that at least GNAT implements Ada dispatching the
>same way.

Again, implementation issue is irrelevant. It is a subroutine that is
dispatching [in a parameter]. The object is not. The difference
becomes especially clear, when you consider multiple dispatch.

>> It is a complementary view. Either we say that the type of an object
>> is mutating or that the type of a formal parameter does (= changing
>> the dispatch table = changing the subroutine parameter profile). The
>> effect is same. It is no more strongly typed.
>
>In C++, the type of 'this' in a method is always 'pointer-to-class-type-
>of-this-method', or a const variant of that. The (dynamic) type of the
>object pointed to by 'this' can change as control passes through *tors.

This is exaclty what I meant by claiming that it is not a class-wide
pointer. A dispatching subroutine is defined on the whole class
(=closure of the domains of all derived types). Each override
represents a part of its body called according to the type tag. The
behaviour in C++ constructors/destructors clearly violates this. So
either the type is not class-wide or the subroutine is not
dispatching. Choose what you want, the result is same.

>Note that for typical C++ implementations we are not just "saying" that
>the type of the object changes; the generated code actually modifies the
>dispatch table pointer stored within the object as it progresses through
>its construction and destruction. (In fact, I believe Microsoft's C++
>compiler offers an option to disable this for efficiency when you can
>assure it that it won't matter.)

--
Regards,
Dmitry Kazakov
http://www.dmitry-kazakov.de