Re: Merits of re-dispatching

[dmitry@elros.cbb-automation.de (Dmitry A. Kazakov)]

On Thu, 21 Feb 2002 13:17:48 -0500, Hyman Rosen <hyrosen@mail.com>
wrote:

>Dmitry A. Kazakov wrote:
>> OK, it dispatches as if it didn't. Therefore I say that it does not.
>
>Well, you can say anything you like, but it certainly does dispatch
>using the type of the constructor or destructor which is running.
>
>> What happens internally is of no interest.
>
>If that is so, then stop saying that it does not dispatch, because
>that is true *only* internally.

That's the whole point. Dispatching vs. not dispatching is not an
implementation detail, but a part of the contract. It seems that we
are using different definitions of dispatch, thus we'll never agree.

>> The viewpoint of C++ language, but I am not talking about C++
>> definition of "dispatch" and its implementation issues.
>
>You began this discussion by claiming that the equivalent of
>redispatching from Finalize was unsafe in C++,

No. I said exactly the opposite:

"The behaviour of B::~B is safe."

I.e. that C++ behaviour is safe in destructors, because it does not
<dispatch> [= dispatches as if it didn't].

>and I have been
>correcting your mistaken impressions about C++ ever since.
>This has nothing whatever to do with implementations of C++,
>only the definition of its behavior according to its standard.
>
>> I still prefer a model where types of objects are not arbitrarily
>> changed [no matter physically or mentally] depending on what kind of
>> method is used.
>
>You may prefer this, but that is not the way C++ works. It is the
>way Ada works, which leads to the problem you originally noticed,
>of redispatching to code which manipulates already Finalized members.

The single problem with Ada approach is that its application was in my
view not enough puristic and consequent as it could be. Namely, no
re-dispatching should be allowed at all. I definitely do not want that
self-contradictory mixture of types and their closures as in C++.

Regards,
Dmitry Kazakov