Re: tagged record child: override constructor?

["Hyman Rosen" <hyman.rosen@gmail.com>]

Dmitry A. Kazakov wrote:
> meaningful dispatch is rare. How often the specific type is really unknown?

This is just baffling. The whole point of object-oriented
programming is that you have classes which conform to an
interface but have differing implementations, and those
implementations are dispatched to by making a call using a
classwide type. That's the whole reason tagged types were
implemented in Ada 95. Without it, you just have ADTs.

> A goal of Ada design was safe software construction. Putting former C++
> programmers on the right track wasn't. (:-))

How nice for Ada. But what does dispatching have to do
with safety?

> Because having the tag you can determine the object's type, which might
> differ from what the contract states. Ada is based on contract model.

That's how tagged types work. That's the whole point of
tagged types. You're supposed to be able to get at aspects
of the object's real type, via dispatching.

> Because it is the contract to determine what's going on.

You've got a tagged type, so it's methods should dispatch.
That's why you use a tagged type in the first place. When
the method call doesn't dispatch that's surprising and
unexpected. OO came to Ada late. Making its behavior weirdly
different from other OO languages isn't helpful.

> It demonstrates that in the calls made from T::T and T::~T the type of
> "this" is T.

Yes, that's one thing it demonstrates.

> f() in A::g() dispatches only if g() wasn't called [directly or indirectly]
> from a constructor or destructor.

That's false. B::B() and B::~B() both call A::g() (there
is no separate B::g() defined), and that dispatches to
B::f(). There is no difference in the dispatch mechanism
when f() is called, whether or not that call originates
in a constructor. The only difference is what type tag
the object contains when the dispatching happens.