Re: tagged record child: override constructor?

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

Dmitry A. Kazakov wrote:
> Which mistake? Again, it is solely the actual object's *type* which
> determines dispatch.

The mistake of not calling the overridden method of the actual
type of the object rather than of the declared type. In OO
programming, by-reference objects have two types, their declared
base type and their actual created type. In OO programming, it is
expected by the programmers that a call to a potentially overridden
function using a base by-reference object will dispatch to the
overridden function. If the language claims to support OO but then
makes it easy to call these methods in such a way that overriding
doesn't happen, and without warning, then the language has introduced
a dangerous trap. That is supposedly antithetical to the spirit of
Ada.

> It is 100% safe, intuitive and unambiguous.

It is not intuitive at all, except to people whose intuition has
been warped. It's just plain wrong.

> Ada is a typed language! Is C++ one?

It's the Ada language that has caused itself this problem. C++
requires that you clearly distinguish between a reference to an
object, a pointer to an object, and the object itself. Thus,
when you see a pointer or reference to a base class, you know
that the referee object may be of a derived class, and that
dispatching may take place. Ada, in trying to be clever about
hiding parameter passing mode from the programmer, and by not
supporting a distinguished dispatching object syntax, let itself
in for a trap.

> No. It calls B::g() which was inherited from A. I don't care if code of
> B::g() and A::g() share memory or not. They are different functions because
> their signatures are different.

No, they are the same function. If, for example, I included a static
variable within it, calls to A::g() and B::g() would see the same
variable. And for that matter, simply write this:
    #include <iostream>
    #include <ostream>
    struct A { void g(); };
    struct B : A { };
    int main() { std::cout << (&A::g == &B::g) << "\n"; }
and you'll see whether the compiler thinks they're the same or not.

> It does not. It calls B::f() from B::g()

No. There is no B::g separate from A::g. Inherited functions are
not copies, they are the same function. There is no code you can
write which will demonstrate a difference.