Re: Offical Ada FAQ

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Fri, 26 Nov 2004 09:13:41 +1100, Brian May wrote:

>>>>>> "David" == David Botton <david@botton.com> writes:
> 
>     David> Strong typing can be carried too far, and some amount of
>     David> implicit conversion is essential to make OOP palatable. But
>     David> note that in Ada 95, even with OOP, we don't allow implicit
>     David> conversions that truncate the extension part of a record
>     David> (this is a relatively common mistake in C++ when passing
>     David> parameters by value).
> 
> I would be curious to know more about this common mistake in C++...

Perhaps David meant:

class A
{
public :
   int Field1;
};

void Foo (A X);

class B : public A
{
public :
   int Field2;
};

void Foo (A X)
{   
   printf ("%i", ((B*) &X)->Field2); // Surprise, surprise
}

int main ()
{
   B  Baz;

   Baz.Field2 = 123;
   Foo (Baz); // Prints garbage or crashes
   return 0;
}

But the above is NOT a mistake. It is absolutely correct behavior! The
actual error is an attempt to cast to B something what is not B. Should Ada
allow by-value parameter passing for some of tagged types (why not), the
effect would be exactly the same: truncating extra members. The only
difference to C++ would be that [view] conversion to B or B'Class would
raise Constraint_Error, while C++ cast swallows anything told.

> Does this work with both "in", "in out" and "out" parameters?
> 
> For out parameters, what happens if the derived type has extra fields
> not in the parent? Is this legal? If it is legal are the extra fields
> defined?

It is just view conversions. The tag of a tagged "out" parameter is set
before the call, so it is legal and safe (up to Constraint_Error).

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de