Re: Concatenation and Characters

[Robert A Duff <bobduff@shell01.TheWorld.com>]

"Justin Birtwell" <jbirtwell@yahoo.com> writes:

> This is what I don't understand!  How can you declare a string variable when
> you don't know before hand what the string is going to be?

Type String is fixed-length, meaning that you have to know the exact
length when you create a String object.  (But different Strings can be
different lengths.)  Yes, this is somewhat restrictive.

One thing you can do is leave the bounds off.  That's allowed if the
String has an initial value, and the String is then exactly as long as
that value (and its length never changes).  Like this:

    S: String := "ABCD";
    T: String := "EF";
    U: String := S & T; -- U has bounds 1..6.

Note that you can write functions that return "String" -- the length of
the String is determined when the function returns, and can be different
each time it's called.  And you can use a call to initialize a variable
or constant:

    X: constant String := Func(...);

In fact, "&" is really just a built-in function that works this way.

If you really want strings whose length changes over time, you should
use the Bounded or Unbounded_Strings packages.  Unbounded_Strings is the
most flexible.

Your other question was:

> Chars:array range(1..3) of Characters:=('a','b','c');
> 
> How can I convert it to a string?
> 
> Put(Chars) --Compile Error:Invalid param list!

You can use a type conversion, as in:

    Put(String(Chars));

There are lots of complicated rules about what types may be converted to
what other types -- look up "type conversion" in the RM or some
textbook.

By the way, you could have used a string_literal above:

    Chars: array (1..3) of Character := "abc";

String_literals are not specific to type String; they work for any
"string type".  A string type is any one-dimensional array of a
character type.  A character type is any enumeration type that has
character literals -- although you normally only need the predefined
ones Character and Wide_Character.  The (anonymous) type of Chars is a
string type.

Or, you could consider whether you really want Chars to have a separate
type -- you could say:

    Chars: String := "abc";

or

    Chars: constant String := "abc";

if Chars never changes.  Then you can "Put(Chars);".

- Bob