Re: Ada OO Mechanism

[Hyman Rosen <hymie@prolifics.com>]

Richard D Riehle <laoXhai@ix.netcom.com> writes:
> For example, in the same scope and visibility
>          type T is tagged ...
>          function Get(F : some-file) return T;
>          function Get(F : access some-file) return T;
>          function Get(F : some-file) return T'Class;
>          type B is new T with ...
>          function Get(F : some-file) return B;
>          function Get(F : access some-file) return B;

Overloading by return type and having that control dispatching looks
like a good example of something that you can't do in C++. So is the
concept of class-wide type itself - there's no equivalent in C++ for
Ada's T'Class type. From a little fooling around with your code above
and gnat, and the Rationale, it looks like the compiler has to examine
the code that attempts to initialize a T'Class variable and allocate
the maximum space for it that that code would require. C++ doesn't do
any of that - C++ coders would be using dynamic allocation and pointers
or references to pass around arbitray subclasses. Interesting.

>  One of the original contentions was that, although the C++ model of
>              class <=> type <=> module
>  appears to be simpler on the surface, as one begins to design large
>  scale software, that model becomes something of a straightjacket. It
>  utltimately requires friend functions and other encapsulation-breaking
>  features (such as the new "mutable" reserved word) to get around the
>  restrictions imposed by such a small model of object-oriented 
>  programming.

It is a fallacy that friend functions break encapsulation. Friendship
is granted explicitly by a class. These friends are part of the
encapsulation. Mutable has nothing at all to do with this - mutable
members of an object may be modified even when the object is declared
to be 'const'. The intent is to provide a difference between logical
constness and physical constness. For example, one would expect that
the characters of a const string would never change, but there could
be an internal reference count that needs adjustment. That count would
be declared mutable.

For completeness sake, class member templates *can* be used to break
encapsulation. The C++ philosophy is to protect encapsulation against
Murphy but not Machiavelli.