Re: Inherited Methods and such

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Maciej Sobczak <see.my.homepage@gmail.com> writes:

> My claim in this lengthy and philosophical discussion is that C++
> provides a complete solution which can be shortly described like this:
> the final type is not established from the very beginning, but is
> progressively moving along the inheritance chain as the subsequent
> constructors of base types complete their work. Thank's to this,
> primitive operations never dispatch further than what can be
> statically reasoned about.

Thanks for summarizing the discussion for me!

I agree with you that during construction you shouldn't dispatch to the
deeper type(s) -- i.e. the ones that can see parts of the object that
are not yet initialized.

But I find the C++ solution less than ideal -- the programmer might well
expect to dispatch to the deeper type, and be surprised when it doesn't.

Question: why do you want to dispatch at all during construction?
I think I remember you saying you wanted to install the object in some
global data structure.  But that just means you want to create an
access-to-class-wide, and put that somewhere -- no need to dispatch.

In other words, would you be happy with a rule saying you can't dispatch
during construction?  (Never mind, for the moment, whether that's a
compile-time or run-time rule (or some of both).)  If the answer is
"no", please give a realistic example where dispatching during
construction makes sense.  (I apologize if you already did -- as I said,
I got lost in this thread, and I didn't read all of it.)

- Bob