Re: abstract sub programs overriding

["Robert I. Eachus" <rieachus@comcast.net>]

Hyman Rosen wrote:

> I don't think you're answering to the issue at hand. The first question
> is, if you have a class hierarchy where each class has an Initialize
> defined for itself, and you create an object of the most derived class,
> does Ada arrange for all of the Initialize procedures to be called, or
> does each Initialize need to explicitly invoke its parent?

The usual in Ada is to define any tagged type that has a private part 
such that it always gets initialized correctly, independent of whether a 
child class is created, with or without an explicit Initialize.  It is 
also normal to insure that even if the Initialize procedure is called 
twice, there is no problem.

Doing this correctly for Finalization is a bit more complex, because of 
the possibility of an exception during the creation, Initialize call, or 
  Finalize for a child type.

> The second
> question, or observation, is that however it's called, a parent Initialize
> can view-convert its object to classwide type and call a dispatching
> procedure on it. This means that a derived class procedure might be
> called from a parent Initialize before its own Initialize has prepared
> the class. I'm not saying this is common, but DK was saying that this
> couldn't happen in Ada, and I'm saying that it can.

DK is right, in fact I have trouble figuring out which problem you are 
trying to create here.  A view conversion can convert to a parent type, 
but to down convert to a type, the object has to be of that type (or a 
descendant of it).  So what you are imagining sounds like an explicit 
call to Parent.Initialize(Parent_Type(Child_Object)), where 
Parent.Initialize then makes a dispatching call to some other operation 
of the child type.  First, let me say, DON'T DO THAT.  It will be very 
difficult to design real examples where you don't raise an exception. 
Now, as it turns out the only way this could cause a problem is if 
Child.Initialize had a nested call to Parent.Initialize before the 
Initialization of the Child specific fields was completed.  Again, you 
could do that, but you should not for other reasons.  It is much more 
common, however, for such a call to be done for only the parent part of 
the object, for example when creating a child object using an aggregate.
There is no problem in that case, because the (implicit) call to the 
parent Initialize is for an object of the parent type. Also, as I said 
above, and as Dmitry said, there is a two-stage initialization process, 
and it is normal in Ada to insure that all fields where it matters are 
intialized to some default value in the first stage of initialization.

So if you really want to, you could probably design some example program 
where you violate all three of these principles, and it causes a 
problem.  But it is much easier to use Unchecked_Conversion to get to 
the same place.

-- 
                                           Robert I. Eachus

"The only thing necessary for the triumph of evil is for good men to do 
nothing." --Edmund Burke