Re: abstract sub programs overriding

[Hyman Rosen <hyrosen@mail.com>]

Dmitry A. Kazakov wrote:
> The problem is that to construct an object (A) /= to construct the
> dispatching table of its methods (B).

If a constructor is able to call member functions, some choice must
be made as to where dispatching calls will go.

> C++ choice is very close to: A implies B.

Yes.

> Obviously it is a bad choice from many points of view.

It's obviously a good choice from my point of view.

> One of them is safety, as the case shows.

As I said, if calls to member functions are to be permitted,
as they are in C++, Java, and Ada, it must be decided what
happens in the case of dispatching. The C++ approach is the
safest, because when a method is actually reached, it sees
only properly initialized data for its type. If code does
happen to attempt to dispatch to an abstract method, the
result is formally undefined, but in practice implementations
dispatch to a stub function which aborts the program, and thus
the error is detected at the point where it happens.

> True, but in practice it is difficult to view object construction /
> destruction as monolitic or error free.

In C++ construction is neither monolithic nor required to be error-free,
in the sense that any constructor may throw an exception to abort the
creation of an object.


> I think that probably two stage construction is needed.
 > The first one for type specific construction, the second for class-wide
 > one (at least to have dispatching in constructors)

Constructors can always pass arguments up the hierarchy in C++,
so ultimate type information is available if needed. If you want
to require the ultimate class to provide this data with no chance
of forgetting, simply inherit from a virtual base class without a
default constructor.

struct RepositoryOfFinalTypeInformation
{
     int magic_type_code;
     RepositoryOfFinalTypeInformation(int code) : magic_type_code(code) { }
};

struct A : virtual RepositoryOfFinalTypeInformation
{
     A() : RepositoryOfFinalTypeInformation(1)
     {
         if (magic_type_code == 1) /* ultimately A */;
         if (magic_type_code == 2) /* ultimately B */;
         if (magic_type_code == 3) /* ultimately C */;
     }
};

struct B : A
{
     B() : RepositoryOfFinalTypeInformation(2) { }
};

struct C : B { }; /* error - will not compile */
struct C : B
{
     C() : RepositoryOfFinalTypeInformation(3) { } /* Aah. That's better. */
};