Re: abstract sub programs overriding

[Hyman Rosen <hyrosen@mail.com>]

Randy Brukardt wrote:
>>What you as an author want is that any object that is correctly
>>initialized will be finalized, that any object which is not initialized
>>will not be finalized, and there are no objects in the middle.
> 
> Right, but that's a tough property to guarentee, particularly if you want to
> to be reasonably secure from abort and the like.

C++ does its best to guarantee this, but will abort the program if,
during the automatic destruction of objects as a result of a thrown
exception, another exception propagates out of one of these destructors.
There's only so much you can do in cases like that. Even Ada raises a
program error in such cases.

But if you write your destructors so that exceptions can never escape
(which is the recommended style, because throwing an exception out of
a function "means" that the function cannot fulfill its duty, whereas
a destructor has no choice in the matter, since the object is being
destroyed regardless of what the destructor thinks about it), then C++
provides that guarantee - objects are constructed once and any object
which is constructed will be destructed. (Barring manual intervention,
of course.)

 > I think it is best to depend primarily of a valid flag

The problem with a valid flag is that it pushes the responsibility for
validity testing out to all the methods. One of the goals of having a
constructor in OO was to localize object construction in one place, so
every other method could assume that the object was in a consistent and
valid state.

> (For someone who claims to not know Ada very well, Hyman knows Ada very
 > well. He should join the ARG. :-) We could use him.)

:-) It's mostly that I understand in pretty excruciating detail how
things work in C++ (and in Java, to some extent), and the reasons for
those behaviors. When I see that Ada does something differently, I can
try to figure out whether those reasons will have an effect that C++
was designed to avoid. (Note that I'm not claiming C++ is better, I'm
just comparing effects of different decisions.)