Re: abstract sub programs overriding

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

On Wed, 10 Mar 2004 08:08:56 -0500, Hyman Rosen <hyrosen@mail.com>
wrote:

>Dmitry A. Kazakov wrote:
>> To allow /= to force. To re-dispatch in Ada you have do it expilictly
>> by converting the object of a specific type to a class-wide. This is
>> way different (though also problematic) from inconsistent attempts in
>> C++ to view the same thing as both specific and class-wide. This
>> cannot be reconciled.
>
>In C++ you can also choose whether to dispatch or not, but the default
>is to dispatch. If you want to call a function of a particular class,
>you just specify that (eg., Mumble::Foo()) and you get it.

To dispatch vs. not has to be defined by solely the object type. This
is the only right way, IMO, and Ada conforms to it.

>Remember,
>Ada compilers still use a vtable pointer inside each object, not the
>way you would have it, a two-part object/vtable fat pointer.

That tags are embedded in Ada is a consequence of a desire to have
re-dispatch and more generally to have objects with identity. Though
as practice shown it was not needed, because the Rosen trick does the
same and has the advantage of explicit indication that identity is
indeed relevant. However the Ada concept of specific and class-wide
types as different types is one of rare real advances in that swamp
called OO. And yes, the concept could be used for non-tagged types
having the best of both worlds.

>> Huh. So the common point of view is that dispatching on unconstructed
>> objects is good?
>
>As I said, not in C++. But much fuss has been made of claiming that
>C++'s way of dispatching in *tors is "confusing" and there are also
>people who want constructors to be able to easily condition their
>behavior based on the complete type of the object. So Java, and Ada
>too, I suppose, do a two-step initialization. The bits of the object
>are perhaps set to something marginally non-random (in Java it's all
>bits zero; you describe what Ada does below) and then methods are on
>their own to worry about whether things are ready to be used.
>
>> Note also that in Ada it cannot happen.
>
>Really? What if you have a hierarchical class where each base has its
>own Initialize? Is each version responsible for calling the version of
>its base?

Yes, but Initialize is not a constructor in C++ sense. When Ada will
have [first stage] constructors that responsibility will become one of
the compiler.

>What is to keep a base version from converting to classwide
>type and calling a dispatching method which will try to use an unset
>member of the derived class (eg., a file not yet opened)?

That will be difficult to achieve with controlled types because they
have *reverse* order of calls to Initialize, but I understand the
question.

When objects are constructed in two stages, the first stage makes some
basic initialization in a way that a base knows nothing about
children. This initialization *cannot* be overriden by children, only
extended. C++ tries to be conform with that, but it has an unsolvable
problems of its messing with specific vs. class-wide. At this stage no
dispatch is needed and no surprises to expect. This exists in Ada, but
it is not user-definable, yet. The second stage construction can be
made class-wide, so that a base could dispatch from its constructor to
child methods. Note that this construction should be made in a reverse
order - children first, exactly as Initialize in Ada works. That makes
dispatch in base's Initialize safe. To summarize:

1. The first stage constructs a *specific* instance of a Derived_Type,
descendant of Type, out of a raw memory chunk. It creates an object of
the type Derived_Type, but that might be not a valid instance of
Type'Class. This makes

2. the second stage by constructing Type'Class out of Derived_Type.

Returning to your example, if Type is an abstract type, and
Derived_Type has to have File, accessed by Type via some dispatching
method, then File (a handle to) has to be initialized and opened at
the stage one, and the class-wide constructor of Type may safely use
it at the stage two.

IMO Ada model is very close to that.

--
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de