El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Manejo de Archivos

Siguiente ►
►

El manejo de archivos es una parte esencial de la programación en Ada, ya que permite a los programas leer y escribir datos en archivos, lo que es crucial para la persistencia de datos y la comunicación con otros sistemas. En esta sección, aprenderemos cómo trabajar con archivos en Ada, incluyendo la apertura, lectura, escritura y cierre de archivos.

Contenido

  1. Tipos de Archivos en Ada
  2. Apertura y Cierre de Archivos
  3. Lectura de Archivos
  4. Escritura en Archivos
  5. Ejemplo Práctico
  6. Ejercicios Prácticos
  7. Conclusión

Tipos de Archivos en Ada

Ada proporciona varios tipos de archivos que se pueden utilizar dependiendo de las necesidades del programa:

  • Text_IO: Para archivos de texto.
  • Sequential_IO: Para archivos secuenciales de datos binarios.
  • Direct_IO: Para archivos de acceso directo.

En esta sección, nos centraremos en el manejo de archivos de texto utilizando el paquete Ada.Text_IO.

Apertura y Cierre de Archivos

Para trabajar con archivos en Ada, primero debemos abrir el archivo y, una vez que hayamos terminado de trabajar con él, debemos cerrarlo.

Apertura de Archivos

Para abrir un archivo, utilizamos el procedimiento Open del paquete Ada.Text_IO. Este procedimiento requiere especificar el modo de apertura del archivo:

  • In_File: Para abrir un archivo en modo lectura.
  • Out_File: Para abrir un archivo en modo escritura.
  • Append_File: Para abrir un archivo en modo de adición.
with Ada.Text_IO; use Ada.Text_IO;

procedure Open_File_Example is
   File : File_Type;
begin
   -- Abrir un archivo en modo escritura
   Open(File, Out_File, "example.txt");
   -- Aquí irían las operaciones de escritura
   Close(File);
end Open_File_Example;

Cierre de Archivos

Para cerrar un archivo, utilizamos el procedimiento Close del paquete Ada.Text_IO.

Close(File);

Lectura de Archivos

Para leer datos de un archivo de texto, utilizamos los procedimientos Get y Get_Line del paquete Ada.Text_IO.

Lectura de una Línea

with Ada.Text_IO; use Ada.Text_IO;

procedure Read_File_Example is
   File : File_Type;
   Line : String(1 .. 100);
   Last : Natural;
begin
   Open(File, In_File, "example.txt");
   Get_Line(File, Line, Last);
   Put_Line(Line(1 .. Last));
   Close(File);
end Read_File_Example;

Lectura de un Carácter

with Ada.Text_IO; use Ada.Text_IO;

procedure Read_Char_Example is
   File : File_Type;
   Char : Character;
begin
   Open(File, In_File, "example.txt");
   Get(File, Char);
   Put(Char);
   Close(File);
end Read_Char_Example;

Escritura en Archivos

Para escribir datos en un archivo de texto, utilizamos los procedimientos Put y Put_Line del paquete Ada.Text_IO.

Escritura de una Línea

with Ada.Text_IO; use Ada.Text_IO;

procedure Write_File_Example is
   File : File_Type;
begin
   Open(File, Out_File, "example.txt");
   Put_Line(File, "Hello, Ada!");
   Close(File);
end Write_File_Example;

Escritura de un Carácter

with Ada.Text_IO; use Ada.Text_IO;

procedure Write_Char_Example is
   File : File_Type;
begin
   Open(File, Out_File, "example.txt");
   Put(File, 'A');
   Close(File);
end Write_Char_Example;

Ejemplo Práctico

A continuación, se presenta un ejemplo completo que combina la lectura y escritura de archivos.

with Ada.Text_IO; use Ada.Text_IO;

procedure File_Handling_Example is
   Input_File  : File_Type;
   Output_File : File_Type;
   Line        : String(1 .. 100);
   Last        : Natural;
begin
   -- Abrir el archivo de entrada en modo lectura
   Open(Input_File, In_File, "input.txt");
   
   -- Abrir el archivo de salida en modo escritura
   Open(Output_File, Out_File, "output.txt");
   
   -- Leer y escribir cada línea del archivo de entrada al archivo de salida
   while not End_Of_File(Input_File) loop
      Get_Line(Input_File, Line, Last);
      Put_Line(Output_File, Line(1 .. Last));
   end loop;
   
   -- Cerrar ambos archivos
   Close(Input_File);
   Close(Output_File);
end File_Handling_Example;

Ejercicios Prácticos

Ejercicio 1: Contar Líneas en un Archivo

Escribe un programa en Ada que cuente el número de líneas en un archivo de texto.

Solución

with Ada.Text_IO; use Ada.Text_IO;

procedure Count_Lines is
   File : File_Type;
   Line : String(1 .. 100);
   Last : Natural;
   Count : Natural := 0;
begin
   Open(File, In_File, "example.txt");
   while not End_Of_File(File) loop
      Get_Line(File, Line, Last);
      Count := Count + 1;
   end loop;
   Close(File);
   Put_Line("Number of lines: " & Natural'Image(Count));
end Count_Lines;

Ejercicio 2: Copiar Contenido de un Archivo a Otro

Escribe un programa en Ada que copie el contenido de un archivo de texto a otro archivo.

Solución

with Ada.Text_IO; use Ada.Text_IO;

procedure Copy_File is
   Source_File : File_Type;
   Dest_File   : File_Type;
   Line        : String(1 .. 100);
   Last        : Natural;
begin
   Open(Source_File, In_File, "source.txt");
   Open(Dest_File, Out_File, "destination.txt");
   while not End_Of_File(Source_File) loop
      Get_Line(Source_File, Line, Last);
      Put_Line(Dest_File, Line(1 .. Last));
   end loop;
   Close(Source_File);
   Close(Dest_File);
end Copy_File;

Conclusión

En esta sección, hemos aprendido cómo manejar archivos en Ada utilizando el paquete Ada.Text_IO. Hemos cubierto cómo abrir, leer, escribir y cerrar archivos, y hemos visto ejemplos prácticos y ejercicios para reforzar estos conceptos. El manejo de archivos es una habilidad fundamental en la programación, y dominar estos conceptos te permitirá crear aplicaciones más robustas y funcionales.

En la siguiente sección, exploraremos cómo Ada puede interactuar con otros lenguajes de programación, lo que ampliará aún más tus habilidades como programador.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados