Re: tagged record child: override constructor?

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

Dmitry A. Kazakov wrote:
> 1. It is space inefficient. To have T and T'Class same requires keeping the
> type tag in all Ts, while it is only necessary in T'Class.

No Ada implementation takes this approach, though.
They all keep a type tag in every tagged object.

> 3. It is inefficient, because it has to dispatch everywhere

In C++, however, you have already declared some functions to be
dispatching (virtual) and some not. For those functions which are
virtual, dispatching is what's wanted. How many Ada newbies get
completely confused trying to figure out what dispatches and what
doesn't? Do any of them write T'Class the first time?

> 4. It is error-prone because of enforced re-dispatch

It is error-prone not to dispatch, because the first thing everyone
learns about OO is that methods dispatch! It's only after significant
hair-pulling that an Ada newbie will realize why his overriden methods
are not being called.

> 5. When T and T'Class are same, objects have identity.

Huh? All type tags for a given type are identical. Why does embedding
a type tag in an object give it any more identity than not doing so?

> The implementation of Foo stay consistent no matter what a derived type
> would do with Bar.

Except that when the programmer overrides Bar for derived types,
he's going to be monumentally confused as to why Foo isn't calling
it. Foo is going to be consistent, but as far as the programmer is
concerned, it's going to be consistently incorrect.

> Re-dispatch usually indicates a design problem.

What nonsense!

> Yes, they do as if they wouldn't. To me it is that they don't.

As has been repeatedly demonstrated to you, this is just wrong.
Once again, here is the code:

    struct A {
        virtual void f() { print("A"); }
        void g() { f(); }
        A() { g(); }
        ~A() { g(); }
    };
    struct B : A {
        void f() { print("B"); }
        B() { g(); }
        ~B() { g(); }
    };
    int main() { B b; }

This will print "ABBA", demonstrating that dispatching is occuring
within g() even when it is called from a constructor or destructor.