Re: Question about OO programming in Ada

[Hyman Rosen <hyrosen@mail.com>]

Dmitry A. Kazakov wrote:
> 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.

But the common OO languages don't support multiple dispatch,
and whether or not you regard implementation as irrelevant,
it is nevertheless the case that dispatching in those languages
is coordinated around the object type, not separately around each
dispatching function.

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

You either-or is a false dichotomy. As you say, "Each override
represents a part of its body called according to the type tag."
In C++, the type tag stored within the object changes as the code
progresses through constructors and destructors. Didn't I post this
sample code already?

     #include <stdio.h>
     struct A
     {
         virtual void f() { printf("A"); }
         void g() { f(); } // This call is always dispatching
         A() { g(); }
     }
     struct B : A
     {
         void f() { printf("B"); } // overrides A::f
         B() { g(); }
     }
     int main() { B b; b.g(); }

This code prints "ABB". In A::g, the type of 'this' is 'pointer-to-A'.
The dynamic type of '*this' is A when called from A's constructor and
B when called from B's constructor, because the compiler is updating
the tag within the object as its construction progresses. The call to
f in A::g always dispatches using the dynamic type of '*this'.