Re: Equality operator overloading in ADA 83

[bobduff@world.std.com (Robert A Duff)]

In article <mheaney-ya023680002504970023550001@news.ni.net>,
Matthew Heaney <mheaney@ni.net> wrote:
>But no heap  is required:
>
>   subtype Length_Range is Natural range 0 .. 132;
>   type String_Buffer (Length : Length_Range := 0) is
>      record
>         Buffer : String (1 .. Length);
>      end record;

This is a recipe for disaster, IMHO.  You'll end up with programs that
work fine most of the time, but fail when they happen to trip over a
file name longer than 132 characters (or a line in a file, or whatever
it is you're using those strings for).  Furthermore, it's not
particularly efficient to copy around 132 characters all the time, when
most of your strings are around 10 characters long.

No, the heap is the right solution to true varying-length strings.
Unfortunately, Ada 83 doesn't give you the tools needed to avoid storage
leaks without breaking the abstraction.  The tool needed is either
garbage collection, or finalization and user-defined assignment.

>But all of these very real problems were cleaned up in Ada 95.  So you are
>correct that string manipulation - in Ada 83 - can be a pain, but this is
>NOT the case for Ada 95, nor are "Ada strings" somehow more inefficient.

"More inefficient" than what?  Than C's nul-terminated strings?  Perhaps
true, at least in many cases.  But Ada strings *are* more inefficient
than they *could* be.  In particular, there's no way to fix the lower
bound to 1, so the generated code has to carry around 8 bytes of dope,
where 4 would suffice.  And do a subtract to determine the length.  Or
carry 12 bytes, to avoid the subtract.  Don't tell me to use a
discriminated record, because then I lose all kinds of nice notations
(like indexing, slicing, and string literals).

- Bob