Re: Merits of re-dispatching [LONG]

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

On Fri, 8 Feb 2002 13:30:04 -0500, "Hyman Rosen" <hyrosen@mail.com>
wrote:

>"Dmitry A. Kazakov" <dmitry@elros.cbb-automation.de> wrote in message news:3c6392e8.2400843@News.CIS.DFN.DE...
>> First C++ does not make any difference between class wide and specific
>> objects. The same type B is a class wide in B::f () and specific in
>> B::~B (). So the difference in how B::f and B::~B are dealing with
>> calls to g(). This is IMO bad.
>
>This is an incorrect view of what is happening. The type is class-wide
>in both B::f and B::~B. Calls to B::g are dispatching in both. It's just
>that while B::~B is running, the actual type of the object is B, so any
>dispatching happens according to B's virtual functions, even if the B
>part happened to be part of a derived class.

That is one of several possible interpretation of what happens in C++
using Ada terms. However, I prefer mine, because it is consistent with
the fact that the type tag [= vtab] is constant, thus the actual
specific type is also constant. Like in Ada it is only a view
conversion.

>struct A { virtual void foo() { cout << "A::foo\n"; }void call_foo() { foo(); } virtual ~A() { call_foo(); } };
>struct B : A { void foo() { cout << "B::foo\n"; } ~B() { call_foo(); } }
>struct C : B { void foo() { cout << "C::foo\n"; } ~C() { call_foo(); } };
>
>When a C object is destructed, it will print "C::foo"., "B::foo", "A::foo".
>
>> type is already *known*. Thus there is no need in [re-]dispatching. A
>> call to g() can be statically resolved.
>
>As in my example, not if  the object is passed to some other routine which
>makes the dispatching call.

When you pass it to some other routine an implicit specific->class
wide conversion happens, so the routine can dispatch again. An Ada 95
equivalent would be:

procedure Y (A : in out Object'Class);
procedure X (A : in out Object) is
begin
   Y (A'Class (A));
end X;

Exactly this behaviour is IMO unsafe.

Regards,
Dmitry Kazakov