33 - Unit: creación de unidades propias

Vimos en el concepto anterior que Delphi nos provee de una gran cantidad de funcionalidades que debemos invocarlas en la zona de uses de nuestro programa.

Es muy común en Delphi crear distintas unidades y luego invocarlas desde nuestro archivo principal.

Veremos ahora como crear una unidad en Delphi y luego llamar a los procedimientos, funciones, tipos de datos etc. contenidos en la misma.

Problema 1

Desarrollar un programa que permita cargar e imprimir dos vector de 5 elementos de tipo Integer.
Declarar y desarrollar los algoritmos en una unidad separada.

Primero damos los mismos pasos para crear el Proyecto123.

Proyecto123

program Proyecto123;

{$APPTYPE CONSOLE}

begin

end.

Para crear una unidad en nuestro proyecto seleccionamos desde el menú de opciones:

Por defecto el entorno la crea con el nombre Unit1 (podemos luego cambiarla y darle un nombre más significativo con respecto a sus funcionalidades):

Unit1.pas

unit Unit1;

interface

implementation

end.

El entorno de Delphi nos crea un esqueleto mínimo de la unidad donde podemos identificar primero su nombre luego de la palabra clave unit:

unit Unit1;

Luego las dos partes fundamentales de una unidad son la interface y la implementation:

interface

implementation

En la interface disponemos todos los tipos de datos, funciones, procedimientos, variables etc. que queremos que otras unidades o el programa principal tengan acceso.

En la zona de la implementation desarrollamos los algoritmos de las funciones y procedimientos que hemos declarado en la zona de la interface. También en la implementation podemos definir e implementar funciones, procedimientos, tipos de datos que solo tengan acceso dentro de la propia unidad.

Codificaremos los procedimientos para cargar e imprimir el vector y su posterior invocación desde el programa principal.

Unit1.pas

unit Unit1;

interface

  type
    TVector = array[1..5] of Integer;

  procedure Cargar(var Vector: TVector);
  procedure Imprimir(Vector: TVector);

implementation

  procedure Cargar(var Vector: TVector);
  var
    f: Integer;
  begin
    for f:=1 to 5 do
    begin
      Write('Ingrese elemento:');
      ReadLn(Vector[f]);
    end;
  end;

  procedure Imprimir(Vector: TVector);
  var
    f: Integer;
  begin
    for f:=1 to 5 do
    begin
      Write(Vector[f], ' ');
    end;
    WriteLn;
    WriteLn('-------------------------');
  end;

end.

En la zona de la interface declaramos el tipo de dato TVector:

  type
    TVector = array[1..5] of Integer;

También en la interface especificamos las cabeceras de los procedimientos Cargar e Imprimir, esto es necesario para que desde otra unidad o en nuestro caso del archivo principal se puedan llamar a estos dos procedimientos.

Las cabeceras son:

  procedure Cargar(var Vector: TVector);
  procedure Imprimir(Vector: TVector);

En la zona de la implementation desarrollamos los algoritmos de los procedimientos declarados en la interface:

  procedure Cargar(var Vector: TVector);
  var
    f: Integer;
  begin
    for f:=1 to 5 do
    begin
      Write('Ingrese elemento:');
      ReadLn(Vector[f]);
    end;
  end;

  procedure Imprimir(Vector: TVector);
  var
    f: Integer;
  begin
    for f:=1 to 5 do
    begin
      Write(Vector[f], ' ');
    end;
    WriteLn;
    WriteLn('-------------------------');
  end;

Toda unidad en Delphi finaliza con la palabra clave:

end.

Codificamos ahora el programa principal de nuestra aplicación.

Proyecto123

program Proyecto123;

{$APPTYPE CONSOLE}

uses
  Unit1 in 'Unit1.pas';

var
  Vector1: TVector;
  Vector2: TVector;

begin
  WriteLn('Carga del primer Vector');
  Cargar(Vector1);
  WriteLn('Carga del segundo Vector');
  Cargar(Vector2);
  WriteLn('Datos del primer vector');
  Imprimir(Vector1);
  WriteLn('Datos del segundo vector');
  Imprimir(Vector2);
  ReadLn;
end.

Debemos indicar en la zona de uses que accederemos a la Unit1:

uses
  Unit1 in 'Unit1.pas';

No es obligatorio la parte de 'in Unit1.pas' pero lo agregó en forma automática el entorno de Delphi cuando creamos la unit(esto nos indica el nombre del archivo fuente de la unidad)

En la zona de variables globales definimos Vector1 y Vector2 de tipo TVector (podemos comprobar que si borramos el "uses Unit1" se genera un error indicando que no existe el tipo TVector:

var
  Vector1: TVector;
  Vector2: TVector;

Luego el bloque principal de nuestro programa queda definido con la llamada de los procedimientos Cargar e Imprimir definidos en la Unit1:

begin
  WriteLn('Carga del primer Vector');
  Cargar(Vector1);
  WriteLn('Carga del segundo Vector');
  Cargar(Vector2);
  WriteLn('Datos del primer vector');
  Imprimir(Vector1);
  WriteLn('Datos del segundo vector');
  Imprimir(Vector2);
  ReadLn;
end.

Esta forma de organizar los programas en Delphi se verá constantemente cuando entremos a estudiar y analizar la biblioteca VCL (Visual Component Library) que nos permite generar formularios de Windows en forma muy sencilla.