Re: Merits of re-dispatching

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

On Mon, 18 Feb 2002 19:47 +0000 (GMT Standard Time),
brangdon@cix.co.uk (Dave Harris) wrote:

>dmitry@elros.cbb-automation.de (Dmitry A. Kazakov) wrote (abridged):
>> > This should produce B.Foo B.Foo A.Foo A.Foo.
>> 
>> With my correction it will produce:
>> 
>> B.Foo B.Foo B.Foo A.Foo.
>
>Right. So you see that Ada is different from C++, and your description of 
>C++ in Ada terms gives the wrong results. You said earlier that:
>
>    That is one of several possible interpretation of what happens
>    in C++ using Ada terms.
>
>but the other interpretation you offered doesn't correspond to how C++ 
>behaves.

My interpretation was that if C++ dispatches then it treats the type
as class wide,, otherwise as specific. Then the  object is always
treated as specific in all calls from destructor. So what? Maybe it is
hard to simulate, but well possible to explain.

>That was my only point, really. 
>
>> Why on earth a call to Foo from B.Finalize should dispatch? The type
>> is known, so there is only one version of Foo to be called.
>
>Let's not muddle the issue with compiler optimisations. A C++ compiler is 
>allowed to replace dynamic dispatch with static if it can deduce the 
>dynamic type of the object at compile-time.

Which is almost impossible in general case. However it has nothing to
do with optimisation. It is the language design issue.

>Constructors are not a special 
>case (although the deduction is unusually simple for them). All of this is 
>under the "as if" rule. C++ must behave as if it dynamically dispatched in 
>constructors.

Regards,
Dmitry Kazakov