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

Tipus Privats i Paquets Privats

Següent ►
►

En aquest tema, explorarem els tipus privats i els paquets privats en Ada. Aquests conceptes són fonamentals per a la programació modular i l'encapsulació, permetent als desenvolupadors crear codi més segur i mantenible.

Objectius

  • Entendre què són els tipus privats i com s'utilitzen.
  • Aprendre a definir i utilitzar paquets privats.
  • Veure exemples pràctics de tipus i paquets privats.
  • Realitzar exercicis per reforçar els conceptes apresos.

Tipus Privats

Definició

Un tipus privat en Ada és un tipus de dades que es declara en la part visible d'un paquet, però la seva implementació es manté oculta en la part privada del paquet. Això permet encapsular la implementació i exposar només la interfície necessària.

Exemple de Tipus Privat

package Stack_Package is
    type Stack is private;
    procedure Push(S: in out Stack; Element: Integer);
    procedure Pop(S: in out Stack; Element: out Integer);
    function Is_Empty(S: Stack) return Boolean;
private
    type Stack is
        record
            Elements: array (1..100) of Integer;
            Top: Integer := 0;
        end record;
end Stack_Package;

Explicació

  • Part visible: Declarem el tipus Stack com a privat i definim les operacions Push, Pop i Is_Empty.
  • Part privada: Implementem el tipus Stack com un registre amb un array d'elements i un índex Top.

Avantatges dels Tipus Privats

  • Encapsulació: La implementació del tipus està oculta, permetent canvis interns sense afectar el codi que utilitza el tipus.
  • Seguretat: Els usuaris del paquet no poden accedir directament als detalls interns del tipus.

Paquets Privats

Definició

Un paquet privat en Ada és un paquet que conté una part visible i una part privada. La part visible defineix la interfície pública, mentre que la part privada conté la implementació detallada.

Exemple de Paquet Privat

package body Stack_Package is
    procedure Push(S: in out Stack; Element: Integer) is
    begin
        if S.Top < 100 then
            S.Top := S.Top + 1;
            S.Elements(S.Top) := Element;
        else
            raise Constraint_Error with "Stack Overflow";
        end if;
    end Push;

    procedure Pop(S: in out Stack; Element: out Integer) is
    begin
        if S.Top > 0 then
            Element := S.Elements(S.Top);
            S.Top := S.Top - 1;
        else
            raise Constraint_Error with "Stack Underflow";
        end if;
    end Pop;

    function Is_Empty(S: Stack) return Boolean is
    begin
        return S.Top = 0;
    end Is_Empty;
end Stack_Package;

Explicació

  • Part visible: Defineix la interfície pública del paquet.
  • Part privada: Conté la implementació de les operacions Push, Pop i Is_Empty.

Exercicis Pràctics

Exercici 1: Crear un Tipus Privat

Crea un paquet que defineixi un tipus privat Queue amb operacions per afegir elements (Enqueue), eliminar elements (Dequeue) i comprovar si la cua està buida (Is_Empty).

Solució

package Queue_Package is
    type Queue is private;
    procedure Enqueue(Q: in out Queue; Element: Integer);
    procedure Dequeue(Q: in out Queue; Element: out Integer);
    function Is_Empty(Q: Queue) return Boolean;
private
    type Queue is
        record
            Elements: array (1..100) of Integer;
            Front: Integer := 1;
            Rear: Integer := 0;
        end record;
end Queue_Package;

package body Queue_Package is
    procedure Enqueue(Q: in out Queue; Element: Integer) is
    begin
        if Q.Rear < 100 then
            Q.Rear := Q.Rear + 1;
            Q.Elements(Q.Rear) := Element;
        else
            raise Constraint_Error with "Queue Overflow";
        end if;
    end Enqueue;

    procedure Dequeue(Q: in out Queue; Element: out Integer) is
    begin
        if Q.Front <= Q.Rear then
            Element := Q.Elements(Q.Front);
            Q.Front := Q.Front + 1;
        else
            raise Constraint_Error with "Queue Underflow";
        end if;
    end Dequeue;

    function Is_Empty(Q: Queue) return Boolean is
    begin
        return Q.Front > Q.Rear;
    end Is_Empty;
end Queue_Package;

Exercici 2: Utilitzar un Tipus Privat

Utilitza el paquet Queue_Package per crear una cua, afegir elements, eliminar elements i comprovar si la cua està buida.

Solució

with Queue_Package; use Queue_Package;

procedure Test_Queue is
    Q: Queue;
    Element: Integer;
begin
    Enqueue(Q, 10);
    Enqueue(Q, 20);
    Enqueue(Q, 30);

    while not Is_Empty(Q) loop
        Dequeue(Q, Element);
        Put_Line("Element: " & Integer'Image(Element));
    end loop;
end Test_Queue;

Resum

En aquest tema, hem après sobre els tipus privats i els paquets privats en Ada. Hem vist com aquests conceptes ajuden a encapsular la implementació i a crear codi més segur i mantenible. També hem realitzat exercicis pràctics per reforçar els conceptes apresos. En el següent tema, explorarem les unitats genèriques en Ada.

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