Guía mínima de Ada 95

Ristras de caracteres.

    Ada ofrece los tres tipos posibles de ristras de caracteres: tamaño fijo, tamaño limitado y tamaño dinámico.

Cláusula de contexto

    Para usar ristras de tamaño fijo, tamaño limitado y tamaño dinámico, hay que incluir en la cláusula "with" los paquetes "Ada.Strings.Fixed", "ada.Strings.Bounded" y "Ada.Strings.Unbounded", respectivamente.
    with Text_IO, Ada.Strings.Fixed,
         Ada.Strings.Bounded, Ada.Strings.Unbounded;

    En la cáusula "use" sólo hay que incluir "Ada.Strings.Fixed" y "Ada.Strings.Unbounded", ya que las ristras de tamaño limitado (bounded) necesitan una instanciación para fijar la longitud máxima antes de poder usarse.
    use Text_IO, Ada.Strings.Fixed, Ada.Strings.Unbounded;
 

Declaración

    Una ristra de tamaño fijo es básicamente un array de caracteres que se declara con la palabra "String" y especificando el rango de variación de los índices, que debe ser de tipo Positive. (Lo más normal es que este rango empiece en 1).
    sf1, sf2 : String(1..10); --variables de tipo ristra de 10 caracteres

    Antes de declarar ristras de tamaño limitado es necesario instanciar el subpaquete genérico llamado "Ada.Strings.Bounded.Generic_bounded_length" para el tamaño máximo que se desee (esto se hace para poder tener instancias para distintas longitudes).
    package String_max_10 is new Ada.Strings.Bounded.Generic_bounded_length(10);
    use String_max_10;

    Una vez hecho esto se pueden declarar variables de tamaño limitado (tipo "Bounded_string"), cualificando el nombre del tipo con el de la instancia definida.
    sl1, sl2 : String_max_10.Bounded_string; --ristras de hasta 10 caracteres

    Las ristras de longitud dinámica se declaran del tipo "Unbounded_string".
    sd1, sd2 : Unbounded_string; --ristra de longitud dinámica
 

Ristra nula

    En las ristras de tamaño fijo no existe la ristra nula, dado que una variable de tipo "String" siempre tiene la longitud definida (Ada utiliza caracteres de relleno, por defecto es el espacio).

    La ristra nula para las ristras de tamaño limitado está representada por el valor "Null_Bounded_String".
    sl1 := Null_Bounded_String.

    La ristra nula para las ristras de tamaño dinámico está representada por el valor "Null_Unbounded_String".
    sd1 := Null_Unbounded_String;

    También sirve para representar la ristra nula una ristra fija vacía, que se representa mediante dos dobles comillas (""), pero para ello son necesarias las funciones de coversión entre ristras.

Literales ristra

    Un valor de tipo ristra se escribe como una secuencia de caracteres delimitada por comillas dobles: "esto es una ristra". Un valor literal es una ristra de tamaño fijo cuyo tamaño es igual al número de caracteres de que consta (18 en el ejemplo). Los literales de tipo "Character" se delimitan por comillas simples.
    "a"   esto es una ristra.
    'a'  esto es un carácter, no es una ristra.

Conversión entre ristras

     En los respectivos paquetes, existen funciones para convertir ristras de tamaño fijo a ristras de tamaño limitado o dinámico y viceversa.
    sl1 := to_bounded_string("esta linea");  --conversión de string a bounded-string
    sf1 := to_string(sl1);                       --conversión de bounded_string a string
    sd1 := to_unbounded_string("esta linea");--conversión de string a unbounded_string
    sf2 := to_string(sd1);                       --conversión de unbounded_string a string

    La conversión entre ristras limitadas y dinámicas ha de hacerse a través de ristras de tamaño fijo.
    sd2 := to_unbounded_string(to_string(sl1));--conversión limitada->fija->dinámica
    sl2 := to_bounded_string(to_string(sd1));  --conversión dinámica->fija->limitada

    Se puede asignar la ristra nula convirtiendo una ristra fija vacía.
    sl1 := to_bounded_string("");   --asigna la ristra nula a sl1
    sd1 := to_unbounded_string(""); --asigna la ristra nula a sd1

 Asignación

     Se pueden asignar entre sí ristras del mismo tipo (son de distinto tipo las ristras limitadas de diferente tamaño).

     En las ristras de tamaño fijo, la asignación sólo puede realizarse entre ristras del mismo tamaño:
    sf1 := "1234567890";

     Si se necesita asignar una ristra de un tamaño distinto, se puede emplear la operación "move":
    move("prueba", sf1);

    La operación "move" admite hasta 5 parametros:
    procedure Move (Source  : in  String;
                    Target  : out String;
                    Drop    : in  Truncation := Error;
                    Justify : in  Alignment  := Left;
                    Pad     : in  Character  := Space );
 
  • "Source" es la ristra origen
  • "Target" es la ristra destino
  • "Drop" determina que acción se tomará en caso de que la ristra origen sea mayor que la destino (las acciones posibles son: "left", que corta la ristra por la izquierda, "rigth", que corta la ristra por la derecha, y "error")
  • "Justify" determina, en caso de que la ristra origen sea menor que la destino, cómo se situará ("left", a la izquierda, "center", en el centro, y "rigth", a la derecha)
  • "Pad" determina, en caso de que la ristra origen sea menor que la destino, con qué carácter se rellenarán las posiciones sobrantes

Entrada / Salida

    Sólo las ristras de tamaño fijo pueden intervenir en operaciones de entrada/salida (ello no es un gran problema al existir las funciones de conversión).  Una ristra se lee con la operación "get(X)" o "get_line(X,L)", donde X es una variable de tipo "String" y L es una variable de tipo "Natural" o compatible con él. La primera exige que se entre el número exacto de caracteres, de acuerdo con la declaración de la ristra; la segunda permite la entrada de un número menor de caracteres, e indica en el segundo parámetro el índice del último carácter leído (si el rango de la ristra empieza en uno, esto es igual al número de caracteres leídos).
    Cuando se lee una ristra con get_line, los caracteres leídos sustituyen a los correspondientes que hubiese en la ristra, pero el resto quedan como estaban.
    sf1 := "1234567890";
    get_line(sf1,l_sf1); --l_sf1 es una variable de tipo Natural o compatible

    Suponiendo que el usuario introduce la ristra "abcde", sf1 quedará con el valor "abcde67890".
    Asimismo, las ristras de tipo "String" se escriben con las operaciones "put(X)" o "put_line(X)". La diferencia entre ambas es que la segunda produce un salto de línea después de escribir la ristra.

Cálculo de la longitud

    En ristras de tamaño fijo esta operacion carece de sentido. En ristras de tamaño limitado o de tamaño dinámico se utiliza una función llamada "Length", que devuelve la longitud de la ristra.
    x := Length("ULPGC"); --x toma el valor 5
 

Extracción de una subristra

    En ristras de tamaño fijo esta operación se realiza mediante "slices" (rodajas), igual que en los arrays.
    put_line(sf1(1..5));

    En los otros tipos de ristras, se ha de utilizar una función llamada "Slice".
    function Slice ( Source : in Bounded_String; --Source también puede ser del tipo Unbounded_String
                     Inicio : in Positive;
                     Fin    : in Natural )
    return String;

    Move(Slice(sl1,1,5),sf2); --copia en sf2 la subristra formada por los caracteres de sl1 desde el 1 al 5

    Hay que tener cuidado de que los límites del slice estén comprendidos dentro del rango de índices de la ristra, ya que si no se produciría un error.

Concatenación

    Se utiliza como operador de concatenación el operador "&", que funciona entre todo tipo de ristras y entre ristras y caracteres.
    sl2 := To_Bounded_String("algo ");
    sl1 := sl2 & "nada"; --sl1 toma el valor "algo nada"

    Con las ristras de tamaño limitado se puede utilizar la función "append":
    function Append (Left, Right : in Bounded_String;
                     Drop        : in Truncation  := Error )
    return Bounded_String;

    En este caso, la función devuelve la ristra resultante de concatenar "Left" y "Right". El parámetro "Drop" indica qué hacer en caso de que la ristra resultante exceda el tamaño máximo permitido. Los valores posibles de Drop son: "Error" (produce un error), "Left" (trunca la ristra por la izquierda) y "Right" (trunca la ristra por la derecha). Existen versiones para concatenar ristras de tamaño limitado con ristras de tamaño fijo o con caracteres.
    Con las ristras de tamaño dinámico se puede utilizar el procedimiento "append":
    procedure Append (Source   : in out Unbounded_String;
                      New_Item : in Unbounded_String);

    En este caso, no se necesita el parámetro "Drop", ya que el tamaño de las ristras no está límitado. Existen versiones de "Append" para concatenar una ristra de tamaño dinámico con una ristra de tamaño fijo o con un carácter, en este orden.

Localización de una subristra

Operadores relacionales

   Los operadores relaciones (=, /=, <, >, <=, >=) son aplicables entre ristras atendiendo al alfabeto utilizado.

Más sobre ristras...

    Los paquetes "Ada.Strings.Fixed",  "Ada.Strings.Bounded" y "Ada.Strings.UnBounded" contienen un gran número de otras operaciones para el tratamiento de ristras de tamaño fijo, limitado y dinámico respectivamente.

[Anterior][Inicio][Siguiente]