next up previous contents
Siguiente: Atributos First, Last y Subir: Formación (array) Anterior: Porción de una formación   Índice General

Operadores para formaciones unidimensionales

El operador & concatena dos formaciones siempre que sean del mismo tipo (incluyendo dos String). También permite concatenar un elemento con una formación. Por ejemplo:

 procedure Ejemplo_Concatenacion is
    Letra_1, Letra_2   : Character := '*'; 
    Frase_2            : String (1 .. 2); 
    Frase_3            : String (1 .. 3) := (others => ' '); 
    Frase_5            : String (1 .. 5); 
 
    type T_Vector is array (Integer range <>) of Float; 
    Numero_1, Numero_2 : Float := 1.2; 
    Vector_2           : T_Vector(1 .. 2); 
    Vector_3           : T_Vector(1 .. 3) := (others => 0.0); 
    Vector_5           : T_Vector(1 .. 5); 
 begin
    Frase_1 := Letra_1 & Letra_2;
    Frase_5 := Frase_2 & Frase_3;
    Frase_3 := Letra_1 & Frase_2;
    Frase_3 := Frase_2 & Letra_1;; 

    Vector_2 := Numero_1 & Numero_2;
    Vector_5 := Vector_2 & Vector_3;
    Vector_3 := Numero_1 & Vector_2;
    Vector_3 := Vector_2 & Numero_1;
 end Ejemplo_Concatenacion;

Si tenemos formaciones unidimiensionales de Boolean podemos utilizar los operadores and, or, xor y not definidos para el tipo Boolean. El resultado final es que Ada realiza la operación elemento a elemento. De esta forma podemos simular conjuntos. Por ejemplo:

  declare
    type T_Tabla is array (1 .. 3) of Boolean; 
    Tabla_1   : T_Tabla := (True, False, False);
    Tabla_2   : T_Tabla := (True, True,  False);
    Resultado : T_Tabla;
  begin
    Resultado := Tabla_1 or Tabla_2;  --  (True, True, False)
    Resultado := Tabla_1 and Tabla_2; --  (True, False, False)
    Resultado := Tabla_1 xor Tabla_2; --  (False, True, False)
  end;

Igual que ocurre con los registros, puedes utilizar los operadores $=$ y $/=$ para comparar dos formaciones del mismo tipo. Los registros son iguales si cada uno de sus campos es igual; las formaciones son iguales si cada uno de sus elementos es igual. Las formaciones de diferente longitud son siempre diferentes.

También podemos utilizar los operadores $<$, $>$. En este caso Ada comienza a comparar los elementos uno a uno. Mientras ambos elementos sean iguales Ada continua avanzando. Desde que no sean iguales utiliza ese resultado como el valor definitivo de la comparación. Por ejemplo:

         Frase_1 : String(1 .. 10) := "Para todos";
         Frase_2 : String(1 .. 7)  := "Para mi";

         --  Frase_1 > Frase_2 porque 't' > 'm' en la
         --  definicion Ada del tipo Character

Ada comienza a comparar las dos frases. Compara la primera letra de cada frase. Como son iguales, avanza a la siguiente. Así hasta que encuentre alguna diferente (en este caso la 't' y la 'm'). Si todas las letras son iguales (por ejemplo, ``Juan'' y ``Juan Francisco''), Ada considera que es mayor la más grande (ya que es el órden que se utiliza para ordenar alfabéticamente).


next up previous contents
Siguiente: Atributos First, Last y Subir: Formación (array) Anterior: Porción de una formación   Índice General
Javier Miranda 2002-10-03