Re: Merits of re-dispatching [LONG]

["Hyman Rosen" <hyrosen@mail.com>]

"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. Here's an example:

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.