informatika-2022-23: Unitateak

Aurrekariak

Dakigunez programa exekutagarria eskuratzeko iturburu-programaren itzulketa bat burutu behar da, eta horretarako konpiladorearen eta estekatzailearen beharra daukagu. Biak jarraian lan egiten dutelako (lehenik konpiladorea eta ondoren estakatailea) guretzat prozesu bakarra bezala agertzen zaigu. Eskematikoki:

Adibide honetan Aritm unitate bat sortuko dugu eta bezero-programak unitate horren erabilpena egingo du. Adibide honek kopuru osoak landuko ditu oinarrizko eragiketa aritmetikoak eginez.

Aritm.pas

Unitate bat programatuko dugu bere barnean bi funtzio eta prozedura bat izango dituena, unitateari Aritm deituko diogu. Unitatearen iturburu-programari Aritm.pas deituko diogu eta bere kodea ondoko hau da:

unit Aritm ; 

interface
   procedure ZatiduraEtaHondarra(    iZbk1, iZbk2: integer;
                                 var iZati, iHond: integer) ;
   function fniBatu(iZbk1, iZbk2: integer): integer ;
   function fniKendu(iZbk1, iZbk2: integer): integer ;
   
implementation
   procedure ZatiduraEtaHondarra(    iZbk1, iZbk2: integer;
                                 var iZati, iHond: integer) ;
   begin
      iZati := iZbk1 div iZbk2 ;
      iHond := iZbk1 mod iZbk2 ;
   end ;
   
   function fniBatu(iZbk1, iZbk2: integer): integer ;
   begin
      fniBatu := iZbk1 + iZbk2 ;
   end ;
      
   function fniKendu(iZbk1, iZbk2: integer): integer ;
   begin
      fniKendu := iZbk1 - iZbk2 ;
   end ;
end.

Unitateren egiturak bi zati ditu, bat publikoa eta bestea pribatua. Zati publikoa interface blokean zehazten da, deklarazio bat besterik ez da, eta programa-bezeroak ezagutu behar du derrigorrez. Zati pribatua implementation blokean garatzen da eta bere kodea bezeroak ez du zertan ezagutu behar.

Aritm.pas iturburu-programa konpilatu ondoren Aritm.ow objektu-programa eta Aritm.ppw unitate konpilatua lortzen dira. Berez, unitate bat ezin da exekutatu, bere barneko bi funtzioak eta prozedura beste programa batek (unitatearen bezeroak) erabiliko ditu.

Bezero.pas

Orain programa bat idatziko dugu Aritm unitatea erabiliko duena, programa honi Bezero.pas deituko diogu, eta bere kodea programatuko duen programatzaileak unitatearen interfazea ezagutu behar du (interface blokea ezagutu behar du):

interface
   procedure ZatiduraEtaHondarra(    iZbk1, iZbk2: integer; 
                                 var iZati, iHond: integer) ;
   function fniBatu(iZbk1, iZbk2: integer): integer ;
   function fniKendu(iZbk1, iZbk2: integer): integer ;

Bezero.pas programan fniBatu funtzioaren deia egin nahi bada, lehendik Aritm unitatea erabiliko dela adierazi behar du programatzaileak uses klausularen bidez. Ikusi Bezero.pas iturburu-programaren kodea non ZatiduraEtaHondarra, fnBatu eta fnKendu azpiprogramak erabiltzen diren:

{ Bezeroak ezagutzen duena:                                                    }
{ ------------------------                                                     }
{ procedure ZatiduraEtaHondarra(    iZbk1, iZbk2: integer;                     }
{                                var iZati, iHond: integer) ;                  }
{ function fniBatu(iZbk1, iZbk2: integer): integer ;                           }
{ function fniKendu(iZbk1, iZbk2: integer): integer ;                          }
     
program BezeroProgramaBat ;
uses
   Aritm ;

var
   iEragigai1, iEragigai2, iBatura, iKendura, iZatidura, iHondarra: integer ;
   
begin
   writeln ;
   writeln ;
   write('Lehen eragigaia eman: ':30) ;
   readln(iEragigai1) ;
   repeat
      write('Bigarren eragigaia eman: ':30) ;
      readln(iEragigai2) ;
      if iEragigai2 = 0 then
         writeln('Datua ezin daiteke 0 izan':30) ;
   until iEragigai2 <> 0 ;
   
   iBatura := fniBatu(iEragigai1, iEragigai2) ;    { Aritm unitatean garaturik }
   iKendura := fniKendu(iEragigai1, iEragigai2) ;  { Aritm unitatean garaturik }
   ZatiduraEtaHondarra(iEragigai1, iEragigai2,
                       iZatidura, iHondarra) ;     { Aritm unitatean garaturik }
   
   writeln ;
   writeln(iEragigai1:15, '  +  ', iEragigai2, ' = ', iBatura) ;
   writeln(iEragigai1:15, '  -  ', iEragigai2, ' = ', iKendura) ;
   writeln(iEragigai1:15, ' div ', iEragigai2, ' = ', iZatidura) ;
   writeln(iEragigai1:15, ' mod ', iEragigai2, ' = ', iHondarra) ;
   
   readln
end.

Bezero.exe programa exekutagarria eskuratzeko, Bezero.pas programaren iturburu-kodea konpilatu beharra dago. Horretarako, Bezero.pas programaren iturburu-kodea eta Aritm.pas unitatearen iturburu-programa karpeta berean kokatu behar ditugu.

Eskematikoki:

Unitatearen Aritm.pas iturburu-programa ez bagenu? Nola lortuko genuke Bezero.exe programa exekutagarria Bezero.pas iturburu-programatik abiatuta? Bezero.exe programa exekutagarria eskuratzeko, hiru fitxategi hauek beharko genituzke:

Bezero.pas programaren iturburu-kodea,
unitatearen Aritm.ow objektu-programa eta
unitatearen Aritm.ppw unitate konpilatua

Azken bi fitxategiak Aritm.pas unitatearen konpilaziotik eratorriak dira. Aipatutako hiru fitxategi horiek karpeta berean kokatu behar dira Bezero.exe programa exekutagarria lortzearren.

Eskematikoki:

BesteBezero.pas

Orain gure beste programa bat idatziko dugu BesteBezero.pas deituko duguna. Azken programa hau aurreko Bezero.pas programa bezalakoa da (Aritm unitatea erabiliko du), baina BesteBezero.pas programa berriak fniBatu funtzioa garaturik izango du (bi datuen batuketa bat egin ondoren, batura bider 100 egingo du emaitza itzuli aurretik).

BesteBezero.pas programan, 4 eta 3 datuekin fniBatu funtzioaren deia egitean, emaitza zein izango da? Aritm unitatean garaturik dagoen fniBatu funtzioa piztuko balitz emaitza 7 litzateke, baina BesteBezero.pas programan kodetu den fniBatu funtzioa piztuko balitz emaitza 700 litzateke. Erantzuna 700 da, BesteBezero.pas programaren fniBatu funtzioak unitatearen fniBatu funtzioa estaltzen duelako.

{ Bezeroak ezagutzen duena:                                                    }
{ ------------------------                                                     }
{ procedure ZatiduraEtaHondarra(    iZbk1, iZbk2: integer;                     }
{                                var iZati, iHond: integer) ;                  }
{ function fniBatu(iZbk1, iZbk2: integer): integer ;    (* EZ BALEGO BEZALA *) }
{ function fniKendu(iZbk1, iZbk2: integer): integer ;                          }
     
program BesteBezeroProgramaBat ;
uses
   Aritm ;

function fniBatu(iZbk1, iZbk2: integer): integer ;
begin
   fniBatu := (iZbk1 + iZbk2)*100 ;      (* BATURA BIDER 100 *)
end ;
   
(* -------------------------programa nagusia------------------------- *)   
var
   iEragigai1, iEragigai2, iBatura, iKendura, iZatidura, iHondarra: integer ;
   
begin
   writeln ;
   writeln ;
   write('Lehen eragigaia eman: ':30) ;
   readln(iEragigai1) ;
   repeat
      write('Bigarren eragigaia eman: ':30) ;
      readln(iEragigai2) ;
      if iEragigai2 = 0 then
         writeln('Datua ezin daiteke 0 izan':30) ;
   until iEragigai2 <> 0 ;
   
   iBatura := fniBatu(iEragigai1, iEragigai2) ;    { BEZERO-PROGRAMAKOA }
   iKendura := fniKendu(iEragigai1, iEragigai2) ;  { Aritm unitatetik hartutakoa }
   ZatiduraEtaHondarra(iEragigai1, iEragigai2,
                       iZatidura, iHondarra) ;     { Aritm unitatetik hartutakoa }
   
   writeln ;
   writeln(iEragigai1:15, '  +  ', iEragigai2, ' = ', iBatura) ;
   writeln(iEragigai1:15, '  -  ', iEragigai2, ' = ', iKendura) ;
   writeln(iEragigai1:15, ' div ', iEragigai2, ' = ', iZatidura) ;
   writeln(iEragigai1:15, ' mod ', iEragigai2, ' = ', iHondarra) ;
   
   readln
end.