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 unitatea
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:
{================================================unitatearen hasiera=======}
unit Aritm;
{------------------------------------------------zati publikoa-------------}
interface
procedure ZatiduraEtaHondarra( iZbk1, iZbk2: integer;
var iZati, iHond: integer);
function fniBatu(iZbk1, iZbk2: integer): integer;
function fniKendu(iZbk1, iZbk2: integer): integer;
{------------------------------------------------zati publikoa-------------}
{------------------------------------------------zati pribatua-------------}
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;
{------------------------------------------------zati pribatua-------------}
end.
{================================================unitatearen amaiera=======}
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 bezero-programa
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.
Bezero.pas programaren iturburu-kodea eta Aritm.pas unitatearen iturburu-programa konpilatu ondoren, haien objektu-programak estekatu egiten dira Bezero.exe programa exekutagarria eskuratzeko.
Konpilatu/Estekatu ekintzen eskema:
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.
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.
BesteBezero.exe programa exekutagarriaren irteera bat:
|
| Bezero-programaren
fniBatu funtzioak Aritm unitatearen fniBatu funtzioa estaltzen du |
|
Win | Unitate konpilatua eta bezero-programaren iturburu-kodea:
Mac | Unitate konpilatua eta bezero-programaren iturburu-kodea:
|
