Re: Ada Annoyances

[pythoner6@gmail.com]

On Thursday, June 22, 2017 at 3:29:23 AM UTC-4, Dmitry A. Kazakov wrote: 
> In C++ calls to a method go through the virtual table. In Ada they never 
> do because Ada is strongly typed. This gives you performance and type 
> safety (LSP stuff etc) upon inheritance. Re-dispatch is evil from SW 
> design POV.

C++ is also strongly typed (though one might consider Ada a bit more strongly typed), and the vtable is used only if a method is marked virtual.

What do you mean by "re-dispatch" here? How is it different from the dynamic dispatch that happens in Ada with class-wide types?

> It is controlled by the type, because see above, Ada is properly typed. 
> The dispatch never happens on a tagged type T. It always do on a 
> class-wide type T'Class, which is not tagged. T /= T'Class.

Yes, this is exactly this (rather crucial) distinction I didn't really understand. Part of it I think was that the word class didn't have the right associations in my mind, coming from C++ where a class is just one kind of type. In Ada it seems that class refers to a type and it's descendants, e.g. a class of types.

> Not so much similar, C++ type system is broken in that respect. C++ does 
> not distinguish T and T'Class. Semantically C++ class type is sometimes 
> one and sometimes another. E.g. in a constructor or destructor it acts 
> as T. Elsewhere it does as T'Class.

In C++ it is potentially more confusing, as something of type T is always exactly of type T (because it usually lives on the stack and therefore must have a statically known size), but a reference or pointer to T might be of a derived type. Whether or not a method is dynamically dispatched using the vtable is determined by whether or not the method is marked as virtual.

While I'm not so sure that I'd go so far to say that the C++ way is broken, now that I understand how Ada works a bit better, I would probably agree that Ada's solution is cleaner.