Re: Questions

["Nick Roberts" <nickroberts@blueyonder.co.uk>]

"Robert A Duff" <bobduff@shell01.TheWorld.com> wrote in message
news:wcc7k9mi4rb.fsf@shell01.TheWorld.com...

> Jakub Zawadzki <darkjames@poczta.onet.pl> writes:
>
> > It's guestions from my friend
> > Emaix>I have a question. Does a String(1..X) occupy X bytes always, no
> > Emaix> matter what actual length the string has got?
>
> Heh?  The length of the string *is* X.  So yes, it occupies X bytes
> (plus whatever dope is necessary).

Sometimes a srting such as, for example, defined by String(1..10), will
occupy 20 or 40 bytes (plus 'dope information'), unless pragma Pack is
applied to it. This is because normally the compiler will allocate one
'storage element' per character (so as to maximise speed of access to it)
and on some target machines storage elements are 16 or 32 bits in size.
(Some unusual machines have other sizes of storage element.)

The 'dope' information effectively includes the bounds of the array (the 1
and the 10 in my example), but not necessarily in that form. Sometimes dope
the information has to be stored in memory, sometimes it doesn't. Often the
dope information is not stored in the same place as the array contents (the
characters), and often things are done with the dope information which are
not done with the contents. I'm afraid the full story about dope information
is very complex.

A string such as defined by String(1..10) is called a 'fixed-length' string.
Generally it is considered to have the bounds 1 and 10 (and so length 10)
permanently. However, sometimes the 'actual length' of a fixed-length string
is considered to be all the characters in the string minus any trailing
spaces (or NULs). In which case the answer, in essence, to the original
question is "yes": if I declare

   My_Name:  String(1..10) := "Nick      ";
   His_Name: String(1..10) := "Robert    ";

then the contents of My_Name will normally occupy the same amount of space
in memory as His_Name, even though the actual length (as just defined) of
My_Name is 4 and of His_Name is 6. The compiler simply stores the trailing
spaces as ordinary characters.

> >...Second: do
> > Emaix>To_String and To_Unbounded_String conversions copy strings
>
> Probably.

To expand on that reply a little, for both operations
(Ada.Strings.Unbounded_Strings.To_String and
Ada.Strings.Unbounded_Strings.To_Unbounded_String):

* Some implementations may only copy a pointer (and may also need to update
certain internal counters), but this will be rare.

* Most of the time there will be a simple copy of all the contents (the
characters) of the source string.

* In some cases it may be necessary to do more than just copying. For
example, sometimes it will be necessary to 'pack' or 'unpack' the
characters, as well as copying them.

For To_Unbounded_String, most implementations will need to do two things:
firstly, allocating a space on 'the heap' (and updating a pointer to it);
secondly, copying the contents (characters) of the source string into that
space.

I hope this is of some help!

--
Nick Roberts
Jabber: debater@charente.de [ICQ: 159718630]