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

Paquets

Següent ►
►

Els paquets en Ada són una característica poderosa que permet l'organització i la modularització del codi. Els paquets ajuden a agrupar subprogrames, tipus de dades i altres entitats relacionades en una unitat lògica, facilitant la gestió i la reutilització del codi.

Conceptes Clau

  1. Declaració de Paquets: Un paquet es declara amb la paraula clau package.
  2. Especificació i Cos del Paquet: Un paquet es divideix en dues parts: l'especificació (interface) i el cos (implementació).
  3. Visibilitat: Els elements declarats en l'especificació del paquet són visibles per altres unitats que utilitzen el paquet.
  4. Reutilització: Els paquets permeten la reutilització del codi en diferents parts del programa.

Estructura d'un Paquet

Especificació del Paquet

L'especificació del paquet defineix la interfície pública del paquet, és a dir, els elements que seran visibles i accessibles des de fora del paquet.

package My_Package is
    -- Declaració de tipus de dades
    type My_Type is record
        Field1 : Integer;
        Field2 : Float;
    end record;

    -- Declaració de constants
    My_Constant : constant Integer := 10;

    -- Declaració de subprogrames
    procedure My_Procedure(X : in Integer);
    function My_Function(Y : in Float) return Float;
end My_Package;

Cos del Paquet

El cos del paquet conté la implementació dels subprogrames declarats en l'especificació.

package body My_Package is
    procedure My_Procedure(X : in Integer) is
    begin
        -- Implementació de My_Procedure
        Put_Line("Valor de X: " & Integer'Image(X));
    end My_Procedure;

    function My_Function(Y : in Float) return Float is
    begin
        -- Implementació de My_Function
        return Y * 2.0;
    end My_Function;
end My_Package;

Exemple Pràctic

Especificació del Paquet

package Math_Operations is
    -- Declaració de constants
    Pi : constant Float := 3.14159;

    -- Declaració de subprogrames
    function Add(X, Y : Float) return Float;
    function Subtract(X, Y : Float) return Float;
    function Multiply(X, Y : Float) return Float;
    function Divide(X, Y : Float) return Float;
end Math_Operations;

Cos del Paquet

package body Math_Operations is
    function Add(X, Y : Float) return Float is
    begin
        return X + Y;
    end Add;

    function Subtract(X, Y : Float) return Float is
    begin
        return X - Y;
    end Subtract;

    function Multiply(X, Y : Float) return Float is
    begin
        return X * Y;
    end Multiply;

    function Divide(X, Y : Float) return Float is
    begin
        if Y = 0.0 then
            raise Constraint_Error with "Divisió per zero";
        end if;
        return X / Y;
    end Divide;
end Math_Operations;

Utilització d'un Paquet

Per utilitzar un paquet en un altre programa o unitat, es fa servir la clàusula with seguida de la clàusula use per evitar haver de prefixar els noms dels elements del paquet.

with Ada.Text_IO; use Ada.Text_IO;
with Math_Operations; use Math_Operations;

procedure Main is
    A, B, Result : Float;
begin
    A := 10.0;
    B := 5.0;

    Result := Add(A, B);
    Put_Line("Addició: " & Float'Image(Result));

    Result := Subtract(A, B);
    Put_Line("Subtracció: " & Float'Image(Result));

    Result := Multiply(A, B);
    Put_Line("Multiplicació: " & Float'Image(Result));

    Result := Divide(A, B);
    Put_Line("Divisió: " & Float'Image(Result));
end Main;

Exercicis Pràctics

Exercici 1

Descripció: Crea un paquet anomenat String_Operations que contingui subprogrames per a les següents operacions amb cadenes:

  • Concatenació de dues cadenes.
  • Comprovació si una cadena és un palíndrom.

Solució:

Especificació del Paquet

package String_Operations is
    function Concatenate(S1, S2 : String) return String;
    function Is_Palindrome(S : String) return Boolean;
end String_Operations;

Cos del Paquet

package body String_Operations is
    function Concatenate(S1, S2 : String) return String is
    begin
        return S1 & S2;
    end Concatenate;

    function Is_Palindrome(S : String) return Boolean is
        Reverse_S : String := S'Range => S(S'Last .. S'First);
    begin
        return S = Reverse_S;
    end Is_Palindrome;
end String_Operations;

Exercici 2

Descripció: Utilitza el paquet String_Operations en un programa que llegeixi dues cadenes de l'usuari, les concateni i comprovi si la cadena resultant és un palíndrom.

Solució:

with Ada.Text_IO; use Ada.Text_IO;
with String_Operations; use String_Operations;

procedure Main is
    S1, S2, Result : String(1 .. 100);
    Len1, Len2 : Natural;
begin
    Put("Introdueix la primera cadena: ");
    Get_Line(S1, Len1);
    S1 := S1(1 .. Len1);

    Put("Introdueix la segona cadena: ");
    Get_Line(S2, Len2);
    S2 := S2(1 .. Len2);

    Result := Concatenate(S1, S2);
    Put_Line("Cadena concatenada: " & Result);

    if Is_Palindrome(Result) then
        Put_Line("La cadena resultant és un palíndrom.");
    else
        Put_Line("La cadena resultant no és un palíndrom.");
    end if;
end Main;

Resum

En aquesta secció, hem après sobre els paquets en Ada, incloent la seva estructura, com es declaren i com es poden utilitzar per modularitzar i organitzar el codi. També hem vist exemples pràctics i exercicis per reforçar els conceptes apresos. Els paquets són una eina essencial per a la programació en Ada, ja que permeten una millor gestió del codi i la seva reutilització.

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