Re: Encapsulation in Ada vs. C++ (Was Re: Ichibah [sic] ...)

[dag@control.lth.se (Dag Bruck)]

In <comp.lang.ada> magnus@lglsun.epfl.ch (Magnus Kempe) writes:
>dag@control.lth.se (Dag Bruck) writes:
>: A [C++] class grants friendship to other functions or classes, which means
>: that the author of a class controls who gets access to the private
>: members of the class.  You cannot grant yourself access to any random
>: class.
>
>If your class Foo grants "friendship" to a function/class Bar, _anyone_
>can write such a function/class and, having granted itself "friendliness",
>will have access to the internals of Foo.

If we assume that the author of a class also writes the
classes/functions he/she grants friendship, the "one definition rule"
prohibits you from writing a second function or class with the same
name.

The alternative, that the author grants friendship without actually
writing the friend classes/functions, seems highly unlikely.

If you manipulate library files, for example, replace standard
functions with functions you have written yourself, then you can of
course get access to anything.  You may also patch the symboltable or
the objectcode itself.  However, I doubt that Ada is safer in this
respect.

There is a much simpler way to break encapsulation (and I'm sure
Magnus Kempe wants to hear it): write a your own class with the same
contents and copy the bits from the protected object to a look-alike
object with standard C function "memcpy".

I doubt that "unsafe" features of this nature is of any real interest.
Can anyone give a plausible example?


			-- Dag