Guía mínima de Ada 95

Subprogramas.

Definición de subprogramas.

Un subprograma es un procedimiento o función. La estructura de la definición de un subprograma consta de tres elementos:
  1. Cabecera
  2. Declaraciones locales
  3. Sentencias ejecutables

La cabecera describe el protocolo del subprograma, y consta de: especificación de "procedure" o "function", nombre del subprograma, lista de parámetros y tipo del resultado, caso de ser una function.

procedure Nombre_procedimiento (parámetros) is

function Nombre_función (parámetros) return Tipo is

La lista de parámetros está formada por especificaciones de parámetros formales separadas por ";". Cada especificación de parámetros consta de una lista de nombres de parámetros separados por "," y seguida de ":", el modo de paso (in, out o in out) y el tipo de los parámetros.

procedure LisParam(S1,S2: in integer;S3: out float) is

  • Los parámetros "in" son constantes y no pueden modificarse en el subprograma.
  • Los parámetros "in out" pueden usarse y modificarse.
  • Las funciones sólo tienen parámetros "in".
    • La parte de sentencias ejecutables comienza con la palabra "begin" y abarca hasta que aparezca la palabra "end" seguida del nombre del subprograma y ";".

    La parte de declaraciones locales abarca desde la cabecera hasta la palabra "begin" que da comienzo a las sentencias ejecutables. Los elementos declarados (variables, tipos, subtipos, procedimientos,...) tienen ámbito estático.

    --Ejemplo de subprogramas
    with Text_IO; use Text_IO;
    procedure Ejemplo is --procedimiento principal Ejemplo
      --requerimientos de entrada/salida;
      package Sal1 is new Integer_IO(integer);
      package Sal2 is new Float_IO(float);
      use Sal1, Sal2;
      --función local EsPar
      function EsPar(x: in integer) return boolean is
      begin
          return ((x rem 2) = 0);
      end EsPar;
      --procedimiento local Media
      procedure Media(x,y: in float;med: out float) is
          dos: float; --variable local
      begin
          dos := 2.0;
          med := (x + y) / dos;
      end Media;

      R1,R2,R3 : float; --variables locales de Ejemplo
      i : integer;
    begin
        put("Entre un numero: ");
        Get(i); skip_line;
             if EsPar(i) then put_line("es par"); else put_line("no es par"); end if;
        put("Entre una pareja de numeros separados por un espacio: ");
        Get(R1); Get(R2); skip_line;
        Media(R1,R2,R3);
        Put(R3); new_line;
    end Ejemplo;
     

    Sobrecarga de operadores.

    Ada permite que el programador sobrecargue los operadores del lenguaje, esto es, que pueda redefinirlos dándoles nuevos significados. Para sobrecargar un operador, simplemente hay que definir una función cuyo nombre sea el operador entre comillas y que tenga los parámetros adecuados. Por ejemplo, dado el siguiente tipo:
    type Complejo is record
        PReal, PImag: float;
    end Complejo;

    podemos sobrecargar el operador de suma ("+") para utilizarlo con el fin de sumar números complejos:

    function "+"(A, B : in Complejo) return Complejo is
        Suma: Complejo;
    begin
        Suma.PReal := A.PReal + B.PReal;
        Suma.PImag := A.PImag + B.PImag;
        return Suma;
    end "+";

    Una vez definida esta función, se puede aplicar el operador entre variables del tipo definido en los parámetros, devolviendo un valor del tipo definido como resultado.
    ...
    S, X, Y: Complejo;
    ...
    S := X + Y;

    Sólo se pueden redefinir los operadores del lenguaje (no se pueden inventar operadores), y siempre manteniendo su cardinalidad (los binarios se redefinirán con funciones de dos parámetros y los unarios con funciones de un parámetro).


    [Anterior] [Inicio][Siguiente]