string - Ada: Hacer que el usuario ingrese una Cadena(1..10) y llenar el resto con espacios en blanco

input

Question

He definido

subtype String10 is String(1..10);

y estoy intentando ingresar el teclado sin tener que ingresar manualmente el espacio en blanco antes de presionar enter. Probé get_line () pero por alguna razón no esperaba realmente la entrada antes de enviar el comando get put (), y también creo que dejará lo que haya antes en la cadena y no lo rellenará con espacios en blanco.

Conozco y he usado Bounded_String y Unbounded_String, pero me pregunto si hay alguna forma de que esto funcione.

Intenté hacer una función para eso:

--getString10--
procedure getString10(s : string10) is
   c : character;
   k : integer;
begin
   for i in integer range 1..10 loop
      get(c);
      if Ada.Text_IO.End_Of_Line = false then
         s(i) := c;
      else
         k := i;
         exit;
      end if;
   end loop;

   for i in integer range k..10 loop
      s(i) := '' '';
   end loop;
end getString10;

pero, aquí, sé que el s(i) no funciona, y no creo que el

"if Ada.Text_IO.End_Of_Line = false then" 

hace lo que espero que haga tampoco. Es solo un marcador de posición mientras busco la manera real de hacerlo.

He estado buscando por un par de horas, pero la documentación de Ada no está tan disponible o es tan clara como otros idiomas. He encontrado mucho sobre cómo obtener cadenas, pero no es lo que estoy buscando.

Answer 1

Como alternativa, use la function Get_Line , que devuelve una String longitud fija que "tiene un límite inferior de 1 y un límite superior de la cantidad de caracteres leídos". El ejemplo Line_By_Line usa la variación que se lee de un archivo. Si es necesario, puede usar el procedure Move para copiar la cadena Source a la cadena Target ; el procedimiento rellena automáticamente con espacio de forma predeterminada.

Adición: por ejemplo, este Line_Test con * y silenciosamente trunca las líneas largas a la derecha.

with Ada.Integer_Text_IO;
with Ada.Strings.Fixed;
with Ada.Text_IO;

procedure Line_Test is
   Line_Count : Natural := 0;
   Buffer: String(1 .. 10);
begin
   while not Ada.Text_IO.End_Of_File loop
      declare
         Line : String := Ada.Text_IO.Get_Line;
      begin
         Line_Count := Line_Count + 1;
         Ada.Integer_Text_IO.Put(Line_Count, 0);
         Ada.Text_IO.Put_Line(": " & Line);
         Ada.Strings.Fixed.Move(
            Source  => Line,
            Target  => Buffer,
            Drop    => Ada.Strings.Right,
            Justify => Ada.Strings.Left,
            Pad     => ''*'');
         Ada.Integer_Text_IO.Put(Line_Count, 0);
         Ada.Text_IO.Put_Line(": " & Buffer);
      end;
   end loop;
end Line_Test;

Answer 2

Simplemente preinicialice la cadena con espacios antes de llamar a Get_Line .

Aquí hay un pequeño programa que acabo de lanzar:

with Ada.Text_IO; use Ada.Text_IO;
procedure Foo is
    S: String(1 .. 10) := (others => '' '');
    Last: Integer;
begin
    Put("Enter S: ");
    Get_Line(S, Last);
    Put_Line("S = """ & S & """");
    Put_Line("Last = " & Integer''Image(Last));
end Foo;

y la salida que obtengo cuando la ejecuto:

Enter S: hello
S = "hello     "
Last =  5

Otra posibilidad, en lugar de preinicializar la cadena, es establecer el resto en espacios después de la llamada Get_Line :

with Ada.Text_IO; use Ada.Text_IO;
procedure Foo is
    S: String(1 .. 10);
    Last: Integer;
begin
    Put("Enter S: ");
    Get_Line(S, Last);
    S(Last+1 .. S''Last) := (others => '' '');
    Put_Line("S = """ & S & """");
    Put_Line("Last = " & Integer''Image(Last));
end Foo;

Para arreglos muy grandes, el último enfoque podría ser más eficiente porque no asigna la porción inicial de la cadena dos veces, pero en la práctica es poco probable que la diferencia sea significativa.