El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Unitats Genèriques

Següent ►
►

Les unitats genèriques en Ada són una característica poderosa que permet la creació de codi reutilitzable i flexible. Les unitats genèriques permeten definir plantilles de codi que poden ser instanciades amb diferents tipus o valors, proporcionant una manera de crear components de programari que poden treballar amb diferents tipus de dades sense duplicar el codi.

Conceptes Clau

Definició d'Unitats Genèriques

Una unitat genèrica es defineix utilitzant la paraula clau generic, seguida de la declaració dels paràmetres genèrics. Aquests paràmetres poden ser tipus, subprogrames, paquets o valors.

Instanciació d'Unitats Genèriques

Una vegada definida una unitat genèrica, es pot instanciar amb tipus o valors específics utilitzant la paraula clau new.

Tipus de Paràmetres Genèrics

  1. Tipus Genèrics: Permeten que una unitat genèrica treballi amb diferents tipus de dades.
  2. Subprogrames Genèrics: Permeten passar procediments o funcions com a paràmetres.
  3. Paquets Genèrics: Permeten passar paquets complets com a paràmetres.
  4. Valors Genèrics: Permeten passar valors literals com a paràmetres.

Exemples Pràctics

Exemple 1: Tipus Genèrics

Definim una unitat genèrica que implementa una pila (stack) per a qualsevol tipus de dades.

generic
   type Item_Type is private;
   Max_Size : Positive;
package Generic_Stack is
   procedure Push(Item : in Item_Type);
   procedure Pop(Item : out Item_Type);
   function Is_Empty return Boolean;
   function Is_Full return Boolean;
end Generic_Stack;

Instanciem la pila per a un tipus específic, com ara Integer.

package Integer_Stack is new Generic_Stack(Item_Type => Integer, Max_Size => 100);

Exemple 2: Subprogrames Genèrics

Definim una unitat genèrica que accepta una funció de comparació com a paràmetre.

generic
   type Item_Type is private;
   with function "<" (Left, Right : Item_Type) return Boolean;
package Generic_Sort is
   procedure Sort(Array : in out Array_Type);
end Generic_Sort;

Instanciem la unitat genèrica amb una funció de comparació per a Integer.

function Integer_Less (Left, Right : Integer) return Boolean is
begin
   return Left < Right;
end Integer_Less;

package Integer_Sort is new Generic_Sort(Item_Type => Integer, "<" => Integer_Less);

Exercicis Pràctics

Exercici 1: Creació d'una Llista Genèrica

  1. Definició: Crea una unitat genèrica per a una llista enllaçada que pugui emmagatzemar qualsevol tipus de dades.
  2. Instanciació: Instancia la llista per a un tipus Float.
-- Definició de la unitat genèrica
generic
   type Item_Type is private;
package Generic_List is
   type Node_Ptr is access all Node;
   type Node is record
      Data : Item_Type;
      Next : Node_Ptr;
   end record;

   procedure Add_Item(Head : in out Node_Ptr; Item : in Item_Type);
   procedure Print_List(Head : in Node_Ptr);
end Generic_List;

-- Instanciació per a Float
package Float_List is new Generic_List(Item_Type => Float);

Exercici 2: Ordenació Genèrica

  1. Definició: Crea una unitat genèrica per a ordenar un array de qualsevol tipus de dades.
  2. Instanciació: Instancia la unitat per a un array de String.
-- Definició de la unitat genèrica
generic
   type Item_Type is private;
   with function "<" (Left, Right : Item_Type) return Boolean;
package Generic_Sort is
   procedure Sort(Array : in out Array_Type);
end Generic_Sort;

-- Instanciació per a String
function String_Less (Left, Right : String) return Boolean is
begin
   return Left < Right;
end String_Less;

package String_Sort is new Generic_Sort(Item_Type => String, "<" => String_Less);

Errors Comuns i Consells

  1. Oblidar la Paraula Clau generic: Assegura't d'incloure la paraula clau generic abans de definir els paràmetres genèrics.
  2. Tipus Incompatibles: Quan instancies una unitat genèrica, assegura't que els tipus i subprogrames proporcionats són compatibles amb els paràmetres genèrics definits.
  3. Manca de Flexibilitat: Utilitza paràmetres genèrics de tipus private per assegurar la màxima flexibilitat i reutilització del codi.

Conclusió

Les unitats genèriques en Ada proporcionen una manera poderosa i flexible de crear codi reutilitzable. Comprendre com definir i instanciar unitats genèriques és essencial per escriure programes modulars i mantenibles. Amb la pràctica, podràs aprofitar al màxim aquesta característica per millorar l'eficiència i la qualitat del teu codi.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats