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

Tipos Privados y Paquetes Privados

Siguiente ►
►

En este tema, exploraremos los conceptos de tipos privados y paquetes privados en Ada. Estos conceptos son fundamentales para la encapsulación y la modularidad en la programación, permitiendo a los desarrolladores ocultar detalles de implementación y exponer solo las interfaces necesarias.

Objetivos del Tema

  • Comprender qué son los tipos privados y cómo se utilizan.
  • Aprender a definir y usar paquetes privados.
  • Ver ejemplos prácticos de tipos y paquetes privados.
  • Realizar ejercicios para reforzar los conceptos aprendidos.

Tipos Privados

Definición

Un tipo privado en Ada es un tipo cuyo detalle de implementación está oculto del usuario del paquete. Solo se expone la interfaz pública, mientras que la implementación real se mantiene privada dentro del paquete.

Ventajas

  • Encapsulación: Oculta los detalles de implementación.
  • Modularidad: Facilita la división del código en módulos independientes.
  • Mantenimiento: Permite cambiar la implementación sin afectar a los usuarios del tipo.

Sintaxis Básica

package Mi_Paquete is
    type Mi_Tipo_Privado is private;
    procedure Operacion (X : in out Mi_Tipo_Privado);
private
    type Mi_Tipo_Privado is record
        Campo1 : Integer;
        Campo2 : Float;
    end record;
end Mi_Paquete;

Explicación del Código

  • Declaración Pública: type Mi_Tipo_Privado is private; declara el tipo privado en la parte pública del paquete.
  • Declaración Privada: type Mi_Tipo_Privado is record ... end record; define la estructura del tipo en la parte privada del paquete.
  • Procedimiento: procedure Operacion (X : in out Mi_Tipo_Privado); declara un procedimiento que opera sobre el tipo privado.

Ejemplo Práctico

package Cuentas_Bancarias is
    type Cuenta is private;
    procedure Depositar (C : in out Cuenta; Monto : Float);
    procedure Retirar (C : in out Cuenta; Monto : Float);
    function Saldo (C : Cuenta) return Float;
private
    type Cuenta is record
        Numero : Integer;
        Balance : Float;
    end record;
end Cuentas_Bancarias;

package body Cuentas_Bancarias is
    procedure Depositar (C : in out Cuenta; Monto : Float) is
    begin
        C.Balance := C.Balance + Monto;
    end Depositar;

    procedure Retirar (C : in out Cuenta; Monto : Float) is
    begin
        C.Balance := C.Balance - Monto;
    end Retirar;

    function Saldo (C : Cuenta) return Float is
    begin
        return C.Balance;
    end Saldo;
end Cuentas_Bancarias;

Paquetes Privados

Definición

Un paquete privado en Ada es un paquete que contiene una sección privada, donde se pueden declarar tipos y subprogramas que no son accesibles desde fuera del paquete.

Ventajas

  • Encapsulación: Oculta detalles de implementación dentro del paquete.
  • Seguridad: Protege los datos y subprogramas de accesos no autorizados.
  • Organización: Mejora la organización del código al separar la interfaz pública de la implementación privada.

Sintaxis Básica

package Mi_Paquete_Privado is
    type Mi_Tipo is private;
    procedure Operacion_Publica (X : in out Mi_Tipo);
private
    procedure Operacion_Privada (X : in out Mi_Tipo);
end Mi_Paquete_Privado;

Explicación del Código

  • Parte Pública: Contiene la declaración del tipo y los subprogramas accesibles desde fuera del paquete.
  • Parte Privada: Contiene subprogramas y detalles de implementación que no son accesibles desde fuera del paquete.

Ejemplo Práctico

package Gestor_Usuarios is
    type Usuario is private;
    procedure Crear_Usuario (U : out Usuario; Nombre : String);
    procedure Cambiar_Contrasena (U : in out Usuario; Nueva_Contrasena : String);
private
    procedure Encriptar_Contrasena (Contrasena : in out String);
    type Usuario is record
        Nombre : String(1..50);
        Contrasena : String(1..50);
    end record;
end Gestor_Usuarios;

package body Gestor_Usuarios is
    procedure Crear_Usuario (U : out Usuario; Nombre : String) is
    begin
        U.Nombre := Nombre;
        U.Contrasena := "default";
        Encriptar_Contrasena(U.Contrasena);
    end Crear_Usuario;

    procedure Cambiar_Contrasena (U : in out Usuario; Nueva_Contrasena : String) is
    begin
        U.Contrasena := Nueva_Contrasena;
        Encriptar_Contrasena(U.Contrasena);
    end Cambiar_Contrasena;

    procedure Encriptar_Contrasena (Contrasena : in out String) is
    begin
        -- Lógica de encriptación
    end Encriptar_Contrasena;
end Gestor_Usuarios;

Ejercicios Prácticos

Ejercicio 1: Definir un Tipo Privado

  1. Crea un paquete llamado Biblioteca que contenga un tipo privado Libro.
  2. Define procedimientos para agregar y eliminar libros, y una función para contar el número de libros.

Solución

package Biblioteca is
    type Libro is private;
    procedure Agregar_Libro (L : in out Libro; Titulo : String);
    procedure Eliminar_Libro (L : in out Libro);
    function Contar_Libros return Integer;
private
    type Libro is record
        Titulo : String(1..100);
        Disponible : Boolean;
    end record;
end Biblioteca;

package body Biblioteca is
    procedure Agregar_Libro (L : in out Libro; Titulo : String) is
    begin
        L.Titulo := Titulo;
        L.Disponible := True;
    end Agregar_Libro;

    procedure Eliminar_Libro (L : in out Libro) is
    begin
        L.Disponible := False;
    end Eliminar_Libro;

    function Contar_Libros return Integer is
    begin
        -- Lógica para contar libros
        return 0; -- Placeholder
    end Contar_Libros;
end Biblioteca;

Ejercicio 2: Crear un Paquete Privado

  1. Crea un paquete llamado Sistema_Seguridad que contenga un tipo privado Usuario.
  2. Define procedimientos para crear usuarios y cambiar contraseñas, y una función para verificar contraseñas.

Solución

package Sistema_Seguridad is
    type Usuario is private;
    procedure Crear_Usuario (U : out Usuario; Nombre : String);
    procedure Cambiar_Contrasena (U : in out Usuario; Nueva_Contrasena : String);
    function Verificar_Contrasena (U : Usuario; Contrasena : String) return Boolean;
private
    procedure Encriptar_Contrasena (Contrasena : in out String);
    type Usuario is record
        Nombre : String(1..50);
        Contrasena : String(1..50);
    end record;
end Sistema_Seguridad;

package body Sistema_Seguridad is
    procedure Crear_Usuario (U : out Usuario; Nombre : String) is
    begin
        U.Nombre := Nombre;
        U.Contrasena := "default";
        Encriptar_Contrasena(U.Contrasena);
    end Crear_Usuario;

    procedure Cambiar_Contrasena (U : in out Usuario; Nueva_Contrasena : String) is
    begin
        U.Contrasena := Nueva_Contrasena;
        Encriptar_Contrasena(U.Contrasena);
    end Cambiar_Contrasena;

    function Verificar_Contrasena (U : Usuario; Contrasena : String) return Boolean is
    begin
        -- Lógica para verificar contraseñas
        return True; -- Placeholder
    end Verificar_Contrasena;

    procedure Encriptar_Contrasena (Contrasena : in out String) is
    begin
        -- Lógica de encriptación
    end Encriptar_Contrasena;
end Sistema_Seguridad;

Conclusión

En esta sección, hemos aprendido sobre los tipos privados y los paquetes privados en Ada. Estos conceptos son esenciales para la encapsulación y la modularidad, permitiendo a los desarrolladores ocultar detalles de implementación y exponer solo las interfaces necesarias. A través de ejemplos prácticos y ejercicios, hemos visto cómo definir y utilizar estos elementos en nuestros programas.

En el próximo módulo, exploraremos la concurrencia y la programación en tiempo real, donde aprenderemos a trabajar con tareas y objetos protegidos en Ada.

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