Re: Merits of re-dispatching [LONG]

["Matthew Heaney" <mheaney@on2.com>]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:1013094178.985786@master.nyc.kbcfp.com...
> Again, this is false for C++. In a C++ constructor or destructor, the
> type of the object is the type of the class of which the constructor or
> destructor is a member. So in the C++ equivalent of Finalize(A), the
> call to Foo(A'Class) would call Foo(A), not Foo(AA), because in
> the destructor of A, the object is an A, not an AA, even when we
> are destructing the A component of an AA. This is good, since, as
> you point out, the AA part is no longer there!

Yes, that's true, but it's easy to think that the virtual member function
call will dispatch, because that's how it works for every other virtual
member function:

class B
{
public:
   virtual ~B();
   virtual void f();
   virtual void g();
};

void B::f()
{
   g();  //dispatches
}

B::~B()
{
   g();  //does not dispatch
}

You have to learn that the call to g() doesn't dispatch in the dtor.  This
behavior is certainly not immediately obvious, especially for those new to
the language.

You seemed to have missed the point about this error-prone feature of C++: a
naive programmer is going to depend on dispatching to occur.  He has to
learn --the hard way-- that the dtor is special.

> True, but the error is that (from their point of view) the wrong function
> gets called, not that the right function gets called on destructed pieces
> of objects.

But the point is that it is an error, that is very easy to make.


> I guess this is another entry for my "why C++ is better than Ada" file :-)

Again, you seemed to have missed the point.  The scenario Dmitry described
cannot happed by accident in Ada95: the programmer must have taken special
action for it to occur.  This is not the case in C++.

(Note that I like C++, and I use it every day.  But by any measure Ada95 is
a much safer language than C++.)