Re: Ada Annoyances

["Randy Brukardt" <randy@rrsoftware.com>]

"Maciej Sobczak" <see.my.homepage@gmail.com> wrote in message 
news:bb2dce33-54bd-426c-9029-f965fa007e3b@googlegroups.com...
...
> In C++ when the object of derived class is constructed, its base class
> constructor is called first and at that time the object is considered to 
> have
> the Base dynamic type, which makes sense, as the derived parts have not
> yet been initialized (they will be initialized in the Derived constructor, 
> which
> will happen later). Only after the base constructor finishes, the dynamic 
> type
> of the object is "promoted" to Derived. This means that virtual calls 
> within
> the Base constructor will never dispatch to Derived variants, which is 
> safer,
> as it prevents accidental access to not-yet-initialized parts of the 
> object from
> virtual functions. We say that from within constructors (and destructors,
> where the same process goes in the reverse direction) the static type is
> equal to the dynamic type of the object.

> Ada does not have this feature and diaptching calls can access 
> uninitialized
> components from derived parts by means of dispatching to the not-yet-born
> parts of the object.

C++ needs this model since it has no way to eliminate dispatching from 
routines. In Ada, where redispatching requires explicit work, the vast 
majority of constructors will never make a dispatching call so there is very 
little risk. The problem in Ada is that there isn't any way to determine 
which routines are used as constructors (they're just ordinary routines), so 
it isn't possible to enforce special rules on them. And banning all 
redispatching seems too draconian.

In any case, this problem is irrelevant. Since it is, in general, impossible 
for the language to determine a safe order of initialization for the 
components of an arbitrary record type (3.3.1 has a complicated set of rules 
attempting to do that, but it is known not to work in all cases, and it's 
unlikely that they're consistently implemented, either), there are much 
worse problems that can be caused by a clueless type constructor (which 
would apply to almost all of us).

Ada at least tries to define the order of initialization (that is, 
elaboration). Most other languages don't even try.

The net takeaway is that a truly type-safe language maybe could be 
constructed, but it would have to be an incredibly simple language with very 
little practical application. So that sort of thing is irrelevant.

                                         Randy.