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

Tipos de Acceso y Punteros

Siguiente ►
►

En este tema, exploraremos los tipos de acceso y punteros en Ada. Los punteros son una herramienta poderosa en la programación que permite la manipulación directa de la memoria. Ada proporciona un enfoque seguro y estructurado para trabajar con punteros a través de los tipos de acceso.

Contenido

  1. Introducción a los Tipos de Acceso
  2. Declaración de Tipos de Acceso
  3. Asignación y Desreferenciación
  4. Gestión de Memoria Dinámica
  5. Ejemplos Prácticos
  6. Ejercicios Prácticos

  1. Introducción a los Tipos de Acceso

En Ada, los punteros se denominan "tipos de acceso". Un tipo de acceso es un tipo de dato que contiene la dirección de una ubicación de memoria donde se almacena un valor de un tipo específico. Los tipos de acceso son útiles para crear estructuras de datos dinámicas como listas enlazadas, árboles y grafos.

  1. Declaración de Tipos de Acceso

Para declarar un tipo de acceso en Ada, utilizamos la palabra clave access. Aquí hay un ejemplo básico:

type Integer_Ptr is access Integer;

En este ejemplo, Integer_Ptr es un tipo de acceso que puede apuntar a un valor de tipo Integer.

  1. Asignación y Desreferenciación

Una vez que hemos declarado un tipo de acceso, podemos asignar y desreferenciar punteros. La asignación se realiza utilizando el operador new, y la desreferenciación se realiza utilizando el operador all.

Asignación

Ptr : Integer_Ptr := new Integer'(10);

En este ejemplo, Ptr es un puntero que apunta a un entero con el valor 10.

Desreferenciación

Value : Integer := Ptr.all;

Aquí, Value obtiene el valor al que apunta Ptr, que es 10.

  1. Gestión de Memoria Dinámica

Ada proporciona mecanismos para gestionar la memoria dinámica de manera segura. Es importante liberar la memoria cuando ya no se necesita para evitar fugas de memoria.

Liberación de Memoria

procedure Free is
   procedure Ada.Unchecked_Deallocation(Object : in out Integer; Name : in out Integer_Ptr);
begin
   Free(Ptr);
end Free;

En este ejemplo, utilizamos Unchecked_Deallocation para liberar la memoria apuntada por Ptr.

  1. Ejemplos Prácticos

Ejemplo 1: Uso Básico de Tipos de Acceso

with Ada.Text_IO; use Ada.Text_IO;

procedure Access_Types_Example is
   type Integer_Ptr is access Integer;
   Ptr : Integer_Ptr := new Integer'(42);
begin
   Put_Line("Value: " & Integer'Image(Ptr.all));
   -- Liberar memoria
   procedure Free is
      procedure Ada.Unchecked_Deallocation(Object : in out Integer; Name : in out Integer_Ptr);
   begin
      Free(Ptr);
   end Free;
   Free;
end Access_Types_Example;

Ejemplo 2: Lista Enlazada Simple

with Ada.Text_IO; use Ada.Text_IO;

procedure Linked_List_Example is
   type Node;
   type Node_Ptr is access Node;
   
   type Node is
      record
         Value : Integer;
         Next  : Node_Ptr;
      end record;
   
   Head : Node_Ptr := null;
   
   procedure Add_Node(Value : Integer) is
      New_Node : Node_Ptr := new Node'(Value => Value, Next => Head);
   begin
      Head := New_Node;
   end Add_Node;
   
   procedure Print_List is
      Current : Node_Ptr := Head;
   begin
      while Current /= null loop
         Put_Line("Value: " & Integer'Image(Current.Value));
         Current := Current.Next;
      end loop;
   end Print_List;
   
begin
   Add_Node(10);
   Add_Node(20);
   Add_Node(30);
   Print_List;
end Linked_List_Example;

  1. Ejercicios Prácticos

Ejercicio 1: Crear y Liberar Memoria

Instrucciones:

  1. Declara un tipo de acceso para un tipo Float.
  2. Asigna un valor a un puntero de tipo Float.
  3. Desreferencia el puntero y muestra el valor.
  4. Libera la memoria asignada.

Solución:

with Ada.Text_IO; use Ada.Text_IO;

procedure Exercise_1 is
   type Float_Ptr is access Float;
   Ptr : Float_Ptr := new Float'(3.14);
begin
   Put_Line("Value: " & Float'Image(Ptr.all));
   -- Liberar memoria
   procedure Free is
      procedure Ada.Unchecked_Deallocation(Object : in out Float; Name : in out Float_Ptr);
   begin
      Free(Ptr);
   end Free;
   Free;
end Exercise_1;

Ejercicio 2: Implementar una Lista Enlazada

Instrucciones:

  1. Declara un tipo de acceso para un nodo de lista enlazada.
  2. Implementa procedimientos para agregar nodos y mostrar la lista.
  3. Agrega varios nodos y muestra la lista.

Solución:

with Ada.Text_IO; use Ada.Text_IO;

procedure Exercise_2 is
   type Node;
   type Node_Ptr is access Node;
   
   type Node is
      record
         Value : Integer;
         Next  : Node_Ptr;
      end record;
   
   Head : Node_Ptr := null;
   
   procedure Add_Node(Value : Integer) is
      New_Node : Node_Ptr := new Node'(Value => Value, Next => Head);
   begin
      Head := New_Node;
   end Add_Node;
   
   procedure Print_List is
      Current : Node_Ptr := Head;
   begin
      while Current /= null loop
         Put_Line("Value: " & Integer'Image(Current.Value));
         Current := Current.Next;
      end loop;
   end Print_List;
   
begin
   Add_Node(5);
   Add_Node(15);
   Add_Node(25);
   Print_List;
end Exercise_2;

Conclusión

En esta sección, hemos aprendido sobre los tipos de acceso y punteros en Ada. Hemos cubierto cómo declarar tipos de acceso, asignar y desreferenciar punteros, y gestionar la memoria dinámica. Además, hemos visto ejemplos prácticos y ejercicios para reforzar los conceptos aprendidos. Con esta base, estarás preparado para utilizar punteros de manera efectiva y segura en tus programas en Ada.

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