fitxategi etiketadun mezuak erakusten. Erakutsi mezu guztiak
fitxategi etiketadun mezuak erakusten. Erakutsi mezu guztiak

2024(e)ko apirilaren 21(a), igandea

Direktorioak: Non gaude?







Gure programetan sarritan egiten dugu hau, baina zer balio jarriko dugu sBIDEA kostantean:

   write(Fitxategiaren izena eman (LIBURUAK adibidez): ');
   readln(sFitxIzenLiburutegia);
   sFitxIzenLiburutegia := sBIDEA + sFitxIzenLiburutegia + '.DAT';

Beste modu batez galdeturik: datu-fitxategia non sortzen da?

  • HemenGaude direktorio bat sortu ordenadorearen edozein tokitan (mahaigainean adibidez), bere barnean HemenGorde direktorio bat sortu
  • HanGorde direktorio bat sortu C:\Dev-Pas direktorioan


Datu-fitxategia non sortzen da? galderari erantzuteko programa bat erakusten da beherago. Zenbakiak gordetzen dituen FitxategiakEtaDirektorioak programa deskriba dezagun urratsez urrats:

  • Hasieran uneko direktorioa erakusten da pantailan GetCurrentDirectory funtzioari esker
  • Ondoren, datu-fitxategiaren sIzena izena teklatuaren bitartez emango du erabiltzaileaak 
  • Datu-fitxaregiaren izen osoa eraikitzen da aurretik bidea jarriz eta ostean gehiagarri bat eta luzapena jarriz, bidearen aukerak hauek dira:
    1.   ''
    2.   'HemenGorde\'
    3.   GetCurrentDir + ''\''
    4.   'HanGorde\'
    5.   '\Dev-Pas\HanGorde\'
    6.   'C:\Dev-Pas\HanGorde\'
    7.   'E:\Dev-Pas\HanGorde\'
    8.   'E:\'
  • Datu-fitxategiaren izen osoa finkaturik bere existentzia aztertzen du programak, eta horren arabera bi bide irekitzen dira:
    • Datu-fitxategia ez bada existitzen sortu eta elementuak biltegitzen dira
    • Datu-fitxategia existitzen bada elementu berriak gehitzen dira bukaeran 

Iturburu-programa konpilatu ondoren FitxategiakEtaDirektorioak.exe programa exekutagarria lortuko dugu eta egikaratzeko bi modu daude: Dev-Pas programazio-ingurune barrutik eta Dev-Pas programazio-ingurunetik kanpo.




Dev-Pas programazio-ingurunetik kanpo

Iturburu-programa konpilatuz FitxategiakEtaDirektorioak.exe programa exekutagarria lortu ondoren, Dev-Pas ingurunetik irten HemenGaude direktoriora joateko eta FitxategiakEtaDirektorioak.exe gainean klik egiteko.


Uneko direktorioa HemenGaude delarik, datu-fitxategiarentzat bide desberdinak aukeratu eta emaitza hauek ikertu:


Bidea Datu-fitxategia non sortzen da
1 '' datu-fitxategia HemenGaude direktorioan
2 'HemenGorde\' datu-fitxategia HemenGorde direktorioan
3 GetCurrentDir + '\' datu-fitxategia HemenGaude direktorioan
4 'HanGorde\' exekuzio-denborako errorea
5 '\Dev-Pas\HanGorde\' datu-fitxategia HanGorde direktorioan
6 'C:\Dev-Pas\HanGorde\' datu-fitxategia HanGorde direktorioan
7 'E:\Dev-Pas\HanGorde\' errorea E: unitatean dauden direktorioen arabera
8 'E:\' E: unitatearen erroan (E: unitatean diskorik badago)




Dev-Pas programazio-ingurune barrutik

FitxategiakEtaDirektorioak.pas iturburu-programa konpilatu eta Dev-Pas programazio-ingurunearen menuko Run project aukera hautatu programa exekutatzeko.


Kasu honetan uneko direktorioa C:\Dev-Pas dela jakinik, datu-fitxategiarentzat bide desberdinak aukeratu eta emaitza hauek ikertu:


Bidea Datu-fitxategia non sortzen da
1 '' datu-fitxategia C:\Dev-Pas direktorioan
2 'HemenGorde\' exekuzio-denborako errorea
3 GetCurrentDir + '\' datu-fitxategia C:\Dev-Pas direktorioan
4 'HanGorde\' datu-fitxategia C:\Dev-Pas\HanGorde direktorioan
5 '\Dev-Pas\HanGorde\' datu-fitxategia C:\Dev-Pas\HanGorde direktorioan
6 'C:\Dev-Pas\HanGorde\' datu-fitxategia C:\Dev-Pas\HanGorde direktorioan
7 'E:\Dev-Pas\HanGorde\' errorea E: unitatean dauden direktorioen arabera
8 'E:\' E: unitatearen erroan (E: unitatean diskorik badago)



FitxategiakEtaDirektorioak.pas iturburu-programa:
program FitxategiakEtaDirektorioak;
 
uses
   sysutils;    (* GetCurrentDir eta FileExists funtzioek behar dutelako *)
 
type
   tfFitxategia = file of integer;
   tsKatea = string[199];
 
 
procedure FitxategiaIkusi(sFitxIzen: tsKatea);
var
   f: tfFitxategia;
   iElementua: integer;
begin
   { uztartu }
   assign(f, sFitxIzen);
   reset(f);
 
   writeln('"', sFitxIzen, '" fitxategiak ', filesize(f), ' elementu ditu, bere edukia:');
   while not eof(f) do
   begin
      read(f, iElementua);
      writeln(iElementua:5);
   end;
   writeln('.....................................................................');
   writeln;
   { itxi }
   close(f);
end;
 
 
procedure FitxategiaSortuEtaBete(sFitxIzen: tsKatea);
var
   f: tfFitxategia;
   iElementua, i, kopurua: integer;
begin
   { uztartu }
   assign(f, sFitxIzen);
   rewrite(f);
 
   write('Zenbat elementu nahi dituzu "', sFitxIzen, '" fitxategian? ');
   readln(kopurua);
 
   randomize; { random-aren hazia hasieratu }
   for i:=1 to kopurua do
   begin
      iElementua:=random(10); { 0 eta 9 arteko zenbakia }
      write(f,iElementua);    { fitxategian idatzi eta hurrengo elementura pasa }
   end;
   { itxi }
   close(f);
end;
 
 
procedure FitxategiariElementuakGehitu(sFitxIzen: tsKatea);
var
   f: tfFitxategia;
   iElementua: integer;
   cErantz: char;
begin
   { uztartu }
   assign(f, sFitxIzen);
   reset(f);
   seek(f, filesize(f));
   repeat
      write('"', sFitxIzen, '" fitxategian gordetzeko zenbaki bat eman: ');
      readln(iElementua);
      write(f, iElementua);
      write('Datu gehiagorik gorde nahi duzu? (B/E): ');
      readln(cErantz);
      cErantz := upcase(cErantz);
   until cErantz <> 'B';
   { itxi }
   close(f);
end;
 
 
{============================PROGRAMA NAGUSIA============================}
 
var
   sIzena: tsKatea;
   cAukera: char;
 
begin
   writeln;
   writeln;
   writeln('Uneko direktorioa: ', GetCurrentDir);
   writeln;
    
   writeln('Lanerako fitxategiaren izena eman ezazu (luzapenik gabe)...');
   write('Adibidez, "Datuak" izena: ');
   readln(sIzena);
 
   writeln;
 
   writeln;
   repeat
      writeln('     "', sIzena, '" fitxategiaren bidea aukeratu:');
      writeln('     1.  ""');;
      writeln('     2.  "HemenGorde\"');
      writeln('     3.  GetCurrentDir + "\"');
      writeln('     4.  "HanGorde\"');
      writeln('     5.  "\Dev-Pas\HanGorde\"');
      writeln('     6.  "C:\Dev-Pas\HanGorde\"');
      writeln('     7.  "E:\Dev-Pas\HanGorde\"');
      writeln('     8.  "E:\"');
      writeln;
      write('Exekuzio-denborako errorea gerta daitekeen arren, bide bat aukeratu: ');
      readln(cAukera);
   until (cAukera >= '1') and (cAukera <= '8');
    
   case cAukera of
      '1': sIzena := '' + sIzena + '_aukera-' + cAukera + '.DAT';
    //'1': sIzena :=      sIzena + '_aukera-' + cAukera + '.DAT';
      '2': sIzena := 'HemenGorde\' + sIzena + '_aukera-' + cAukera + '.DAT';
      '3': sIzena := GetCurrentDir + '\' + sIzena + '_aukera-' + cAukera + '.DAT';
      '4': sIzena := 'HanGorde\' + sIzena + '_aukera-' + cAukera + '.DAT';
      '5': sIzena := '\Dev-Pas\HanGorde\' + sIzena + '_aukera-' + cAukera + '.DAT';
      '6': sIzena := 'C:\Dev-Pas\HanGorde\' + sIzena + '_aukera-' + cAukera + '.DAT';
      '7': sIzena := 'E:\Dev-Pas\HanGorde\' + sIzena + '_aukera-' + cAukera + '.DAT';
      '8': sIzena := 'E:\' + sIzena + '_aukera-' + cAukera + '.DAT';
   end;
 
   writeln;
 
   if fileexists(sIzena) then
   begin
      writeln('"', sIzena, '" fitxategia existitzen da, lan egin dezagun.');
      writeln;
      FitxategiaIkusi(sIzena);
      FitxategiariElementuakGehitu(sIzena);
      FitxategiaIkusi(sIzena);
   end
   else
   begin
      writeln('"', sIzena, '" fitxategia ez da existitzen, sortuko dugu.');
      writeln;
      FitxategiaSortuEtaBete(sIzena);
      FitxategiaIkusi(sIzena);
   end;
 
   writeln;
   write('RETURN sakatu programa bukatzeko');
   readln;
end.
 

2024(e)ko apirilaren 20(a), larunbata

13. astea | kaosa sortzen (fitxategi ordenatu bat desordenatzen)

  kaosa sortzen  

Ariketa honen algoritmoa 11. astean ikusitako kaosa sortzen (array ordenatu bat desordenatzen) ariketan programatu zen berbera da. Orduan informazioa erregistroen array batean zegoen, eta orain erregistroen fitxategi batean.

Erregistroen fitxategi bat daukagu. Erregistroak hiru eremuz osaturik daude: kate bat, zenbaki oso bat eta zenbaki erreal bat. Erregistroen fitxategiaren datu batzuk konstante array batetik hartzen dira. Honako hau da erregistroen fitxategiaren datu-mota:
const
   iKOPURUMAX = 15;
type
   tsKate49 = string[49];
   trdFitxa = record
                 sIzenDeiturak: tsKate49;
                    byDeialdia: byte;      (* osoa, txikia eta positiboa *)
                         rNota: real;
              end ;
   tfrdFitxategi = file of trdFitxa ;

asIZENAK array konstantea da eta horretaz oinarriturik balioak hartuko ditu fitxategiak. Datuen asIZENAK array konstantea alfabetikoki ordenaturik dagoenez, fitxategia ordenaturik egongo da ere. Fitxategia desordenatzeko ardIkasleak eta ardKaotikoak array laguntzaileak erabiliko dira.  

Fitxategiaren edukia ardIkasleak arrayra igaro ondoren, nahasketa burutzen da ardKaotikoak arraya lortzeko. Behin ardKaotikoak arraya daukagula, bere edukia berriro fitxategian gordetzen da. Arrayaren nahasketa ZerrendaNahastu izeneko prozeduran burutzen da eta horretarako datu-mota berezi pare bat sortuko dugu, trdLaguntzaile erregistroa eta tardLaguntzaile arraya. Programaren gainerako tokietan erabilpenik ez dutenez, datu-mota espezifiko horiek ZerrendaNahastu prozedura barruan sortzen dira:
{ bi datu-mota berri sortzen dira, soilik prozedura honetan erabiliko direnak }
procedure ZerrendaNahastu(const ardIkasleak: tardIkasleak;
                                    iLuzera: integer;
                           var ardKaotikoak: tardIkasleak);
type
   trdLaguntzaile = record
                       rdIkaslea: trdFitxa;
                       boGordeta: boolean;
                    end;
   tardLaguntzaile = array[1..iKOPURUMAX] of trdLaguntzaile;
var
   ardLaguntzailea: tardLaguntzaile;
   ...

Fitxategi ordenatu bat desordenatzen duen programa hau izan daiteke:

program KaosaSortzenFitxategiBatean;
uses
   crt; 
const
   iZENBATIKASLE = 12; 
type
   tsKate49 = string[49];
   tasIzenenZerrenda = array[1..iZENBATIKASLE] of tsKate49;
   tarNotenZerrenda = array[1..iZENBATIKASLE] of real;
const
   asIZENAK: tasIzenenZerrenda = ('AGIRRE ROMERO, UNAI',              // 01
                                  'ANGULEMA CARAZO, JON ANDER',       // 02
                                  'BIKARREGI IGLESIAS, JULEN',        // 03
                                  'CANO RUIZ DE HEREDIA, JULIAN',     // 04
                                  'CORRAL EGIA, JOSEBA ANDONI',       // 05
                                  'DIAZ DE ULZURRUN, ROY, LEONOR',    // 06
                                  'EGIGUREN MARKINEZ, IRUNE',         // 07
                                  'ERKIAGA ANDONEGI, IKER',           // 08
                                  'FERNANDEZ FEITO, FELIX',           // 09
                                  'GARTZIA DE ALZA GIL, KATALIN',     // 10
                                  'HERRANZ MARTINEZ, REBECA',         // 11
                                  'IRAGORRI COTANO, MARTIN');         // 12
const
   arNOTAK: tarNotenZerrenda = (4.6,       // 01
                                3.2,       // 02
                                5.7,       // 03
                                4.8,       // 04
                                5.1,       // 05
                                6.1,       // 06
                                7.3,       // 07
                                7.6,       // 08
                                2.8,       // 09
                                9.2,       // 10
                                2.9,       // 11
                                8.5);      // 12                        
type
   trdIkasle = record
                  sNor: tsKate49;
                  rNota: real;
               end;
   tardIkasleak = array[1..iZENBATIKASLE] of trdIkasle;
   
   tsKateLuze = string[199];
   tfrdFitxategi = file of trdIkasle;
 
{ ikasleen izenak eta notak array konstanteetan daude }
procedure FitxategiaSortuEtaBete(sFitxIzen: tsKateLuze; iLuzera: integer);
var
   f: tfrdFitxategi;
   rdIkasleBat: trdIkasle;
   k: integer;
begin
   assign(f, sFitxIzen);
   rewrite(f);
   
   for k:=1 to iLuzera do
   begin
      rdIkasleBat.sNor := asIZENAK[k];
      rdIkasleBat.rNota := arNOTAK[k];
      write(f, rdIkasleBat);
   end;
   
   close(f);
end;
 
{ fitxategiaren edukia pantailaratu }
procedure FitxategiaIkusi(sFitxIzen: tsKateLuze);
var
   f: tfrdFitxategi;
   rdIkasleBat: trdIkasle;
begin
   assign(f, sFitxIzen);
   reset(f);
   
   while not eof(f) do
   begin
      read(f, rdIkasleBat);
      writeln(rdIkasleBat.sNor:57, rdIkasleBat.rNota:15:1);
   end;
   
   close(f);
end;

{ fitxategiaren edukia array batera eraman. iLuzera ez da behar ezaguna delako programa nagusian }
procedure FitxategiArray(sFitxIzen: tsKateLuze; var ardIkasleak: tardIkasleak);
var
   f: tfrdFitxategi;
   rdIkasleBat: trdIkasle;
   k: integer;
begin
   assign(f, sFitxIzen);
   reset(f);
   
   k := 0;
   while not eof(f) do
   begin
      read(f, rdIkasleBat);
      k := k + 1;
      ardIkasleak[k] := rdIkasleBat;
   end;
   
   close(f);
end;

{ arrayaren edukia fitxategian gorde }
procedure ArrayFitxategi(const ardKaotikoak: tardIkasleak; iLuzera: integer; sFitxIzen: tsKateLuze);
var
   f: tfrdFitxategi;
   rdIkasleBat: trdIkasle;
   k: integer;
begin
   assign(f, sFitxIzen);
   rewrite(f);
   
   for k:=1 to iLuzera do
   begin
      rdIkasleBat := ardKaotikoak[k];
      write(f, rdIkasleBat);
   end;
   
   close(f);
end;

{ arrayaren edukia pantailaratu }
procedure DatuakIkusi(const ardIkasleak: tardIkasleak; iLuzera: integer);
var
   k: integer;
begin
   for k:=1 to iLuzera do
   begin
      writeln(k:10, ' . ikaslea: ', ardIkasleak[k].sNor:40, ardIkasleak[k].rNota:10:1);
   end;
end;
 
{ bi datu-mota berri sortzen dira, soilik prozedura honetan erabiliko direnak }
procedure ZerrendaNahastu(const ardIkasleak: tardIkasleak;
                                    iLuzera: integer;
                           var ardKaotikoak: tardIkasleak);
type
   trdLaguntzaile = record
                       rdIkaslea: trdIkasle;
                       boGordeta: boolean;
                    end;
   tardLaguntzaile = array[1..iZENBATIKASLE] of trdLaguntzaile;
var
   ardLaguntzailea: tardLaguntzaile;
   k, iZbk: integer;
begin
   for k:=1 to iLUZERA do
   begin
      ardLaguntzailea[k].boGordeta := FALSE;
   end;
 
   randomize;
   for k:=1 to iLuzera do
   begin
      repeat
         iZbk := random(iLUZERA) + 1;
         //writeln('k=', k:2, '----------');
      until ardLaguntzailea[iZbk].boGordeta = FALSE;
       
      ardLaguntzailea[iZbk].boGordeta := TRUE;
      ardLaguntzailea[iZbk].rdIkaslea := ardIkasleak[k];
   end;
 
   for k:=1 to iLUZERA do
   begin
      ardKaotikoak[k] := ardLaguntzailea[k].rdIkaslea;
   end;
end;  
 
{ ---------------------------------- Programa Nagusia ---------------------------------- }
var
   sFitxIzen: tsKateLuze;
   ardIkasleak: tardIkasleak;
   iLuzera: integer;
   ardKaotikoak: tardIkasleak;
begin
   clrscr;
   writeln;
   writeln;
    
   repeat
      write('Zenbat ikasle dira? (1 eta ', iZENBATIKASLE, ' artean): ');
      readln(iLuzera);
   until (iLuzera >= 1) and (iLuzera <= iZENBATIKASLE);
   writeln;
   
   sFitxIzen := 'C:\Ikasleak.dat';
   FitxategiaSortuEtaBete(sFitxIzen, iLuzera);
   
   writeln('===Fitxategi ordenatuaren edukia===============================================');
   FitxategiaIkusi(sFitxIzen);
   writeln;
    
   FitxategiArray(sFitxIzen, ardIkasleak);
   
   writeln('---Array Laguntzailea Nahastu aurretik-----------------------------------------');
   DatuakIkusi(ardIkasleak, iLuzera);
   writeln;
    
   ZerrendaNahastu(ardIkasleak, iLuzera, ardKaotikoak);
    
   writeln('---Array Laguntzailea Nahastu ondoren------------------------------------------');
   DatuakIkusi(ardKaotikoak, iLuzera);
   writeln;
   
   ArrayFitxategi(ardKaotikoak, iLuzera, sFitxIzen);
   
   writeln('===Fitxategi desordenatuaren edukia============================================');
   FitxategiaIkusi(sFitxIzen);
   writeln;
   writeln;
 
   repeat until keypressed;
end.
 

13. astea | fitxategi bat bitan banatu








Aurreko 13. astea | bi fitxategi nahastu ariketaren aurkakoa dela esan genezake!


Zenbakien fitxategi bateko datuak banatu

Demagun abiapuntuko fitxategiak zenbaki osoak dituela, eta datuak sailkatzeko baldintza zenbakia bakoitia/bikoitia izatea dela. Horren arabera progamak banaketa hau egingo du: zenbaki bakoitak fitxategi batera eta zenbaki bikoitiak beste fitxategi batera.

Abiapuntuko fitxategia ez da existitzen horregatik berria sortzen da

Abiapuntuko fitxategia existitzean datuak gehitzen dira

Hasierako fitxategiaren izena erabiltzaileak erabakiko du, goiko irudietan sartzen den izena Zenbakiak da eta programak C:\Datuak\Zenbakiak.DAT osatzen du. Ariketaren emaitza diren bi fitxategien izenak ez ditu erabiltzaileak hautatzen, emaitza diren fitxategiak hauek izango dira:
  • C:\Datuak\Bakoitiak.DAT
  • C:\Datuak\Bikoitiak.DAT   (0 zenbakia bikoititzak hartu)

Hona hemen, proposatutako ariketaren emaitza:
 

Fitxategi bat bitan banatzen duen programa hau izan daiteke:

program FitxategiBatBitanBanatzen;

uses
   sysutils;

type
   tfFitxategia = file of integer;
   tsKatea199 = string[199];


procedure FitxategiaIkusi(sFitxIzen: tsKatea199);
var
   f: tfFitxategia;
   iElementua: integer;
begin
   { uztartu }
   assign(f, sFitxIzen);
   reset(f);

   writeln(sFitxIzen, ' fitxategiak ', filesize(f), ' elementu ditu, bere edukia:');
   while not eof(f) do
   begin
      read(f, iElementua);
      write(iElementua:5);
   end;
   writeln;
   { itxi }
   close(f);
end;


procedure FitxategiaBete(sFitxIzen: tsKatea199);
var
   f: tfFitxategia;
   iElementua, k, iKopurua: integer;
begin
   { uztartu }
   assign(f, sFitxIzen);
   rewrite(f);

   write('Zenbat elementu nahi dituzu ', sFitxIzen, ' fitxategian? ');
   readln(iKopurua);

   randomize; { Random-aren hazia hasieratu }
   for k:=1 to iKopurua do
   begin
      iElementua:=random(10); { 0 eta 9 arteko zenbakia }
      write(f,iElementua);    { fitxategian idatzi eta hurrengo elementura pasa }
   end;
   { itxi }
   close(f);
end;


procedure FitxategiariElementuakGehitu(sFitxIzen: tsKatea199);
var
   f: tfFitxategia;
   iElementua: integer;
   cErantz: char;
begin
   {uztartu}
   assign(f, sFitxIzen);
   reset(f);
   seek(f, filesize(f));
   repeat
      write(sFitxIzen, ' fitxategian gordetzeko zenbaki bat eman: ');
      readln(iElementua);
      write(f, iElementua);
      write('Datu gehiagorik gorde nahi duzu?(B/E): ');
      readln(cErantz);
      cErantz := Upcase(cErantz);
   until cErantz <> 'B';
   { itxi }
   close(f);
end;


procedure FitxategiaBanatu(sFitxIzen, sFitxIzen1, sFitxIzen2: tsKatea199);
var
   f, f1, f2: tfFitxategia;
   iElementua: integer;
begin
   { uztartu }
   assign(f, sFitxIzen);
   reset(f);
   assign(f1, sFitxIzen1);
   rewrite(f1);
   assign(f2, sFitxIzen2);
   rewrite(f2);

   while not eof(f) do
   begin
      read(f, iElementua);
      if iElementua mod 2 <> 0 then
         write(f1, iElementua)
      else
         write(f2, iElementua);
   end;

   { itxi }
   close(f);
   close(f1);
   close(f2);
end;


{===================PROGRAMA NAGUSIA=====================}

var
   sIzena, sIzen1, sIzen2: tsKatea199;

begin
   writeln('Zenbakiak gordeko dituen fitxategiaren izena ''Zenbakiak'' izan daiteke');
   write('Fitxategiaren izena: ');
   readln(sIzena);
   sIzena := 'C:\' + sIzena + '.DAT';

   if fileexists(sIzena) then
   begin
      FitxategiaIkusi(sIzena);
      FitxategiariElementuakGehitu(sIzena);
      FitxategiaIkusi(sIzena);
   end
   else
   begin
      FitxategiaBete(sIzena);
      FitxategiaIkusi(sIzena);
   end;

   sIzen1 := 'C:\' + 'Bakoitiak' + '.DAT';
   sIzen2 := 'C:\' + 'Bikoitiak' + '.DAT';
   writeln('Datuak banatzean ', sIzen1, ' eta ', sIzen2, ' fitxategietan gordeko dira');

   FitxategiaBanatu(sIzena, sIzen1, sIzen2);
   FitxategiaIkusi(sIzen1);
   FitxategiaIkusi(sIzen2);

   writeln;
   write('RETURN sakatu programa bukatzeko');
   readln;
end.
 

13. astea | bi fitxategi nahastu








Ezaguna den ariketa hau fitxategiak erabiliz egin!


Erregistroen bi bektore fitxategi nahastu


Laborategiko gelan, gehienez, 25 ikasle izango dira. Ikasleen datuak bi arrayetan biltzen dira, array bat lehen azterketari dagokio eta beste arraya bigarren azterketari dagokio.

Arrayaren elementuak kateak dira, eta bertan izena eta zenbaki bat / batez banaturik daude, zenbakien kopuru maximoa 9.9 izango eta minimoa 0.0 izango da.

Datuak teklatuaren bitartez ematen dira eta ikasleen posizioak arrayetan zaindu behar dira berdinak izan daitezan, hurrengo adibidean erakusten den bezala. asAzterketa1 eta asAzterketa2 abiapuntuko arrayak dira eta ardAzterketak arraya lortu behar dena. Hona hemen datuen adibide bat:


asAzterketa1
‘Josu/6.1’
‘Ane/7.6’
‘Mikel/2.7’
1
2
3

asAzterketa2
‘Josu/6.9’
‘Ane/5.4’
‘Mikel/6.3’
1
2
3

iLuzera
3



ardAzterketak
‘Josu’
‘Josu’
‘Ane’
‘Ane’
‘Mikel’
‘Mikel’
6.1
6.9
7.6
5.4
2.7
6.3
1
2
3
4
5
6

iZenbat
6



Datu zerrenda bat array batean gorde daiteke, edo bestela fitxategi batean ere gorde daiteke. Ondoko ariketa egin dezagun: bi fitxategietatik abiatuta aurreko biak nahastuz fitxategi bakarra lortu.

Hona hemen, proposatutako ariketaren hasiera:

program ErregistroenBiFitxategiNahastenEMATEKOA;

type
   tsKate30 = string[30];
   tsKate250 = string[250];
   tfsAgendaZahar = file of tsKate30;

procedure DatuakSartu(sFitxIzen1, sFitxIzen2: tsKate250);
var
   f1, f2: tfsAgendaZahar;
   iZenbatElementu: integer;
   sDatua: tsKate30;
   sIzena: tsKate30;
   sZenbakiUnitate: tsKate30;
   sZenbakiHamarreko: tsKate30;
   iZenbakiUnitate: integer;
   iZenbakiHamarreko: integer;
   n: integer;
begin
   assign(f1, sFitxIzen1);
   rewrite(f1);
   assign(f2, sFitxIzen2);
   rewrite(f2);
   
   repeat
      write('Zenbat elementu gordeko dira bi fitxategietan? ');
      readln(iZenbatElementu);
   until iZenbatElementu > 0;
   
   for n:=1 to iZenbatElementu do
   begin
      write(n, '. lagunaren izena eman: ');
      readln(sIzena);
   
      iZenbakiUnitate := random(10);         (* 0 eta 9 artean *)
      Str(iZenbakiUnitate, sZenbakiUnitate);
      iZenbakiHamarreko := random(10);       (* 0 eta 9 artean *)
      Str(iZenbakiHamarreko, sZenbakiHamarreko);
      
      sDatua := sIzena + '/' + sZenbakiUnitate + '.' + sZenbakiHamarreko;
      write(f1, sDatua);     (* Fitxategi batean idatzi *)
   
      iZenbakiUnitate := random(10);         (* 0 eta 9 artean *)
      Str(iZenbakiUnitate, sZenbakiUnitate);
      iZenbakiHamarreko := random(10);       (* 0 eta 9 artean *)
      Str(iZenbakiHamarreko, sZenbakiHamarreko);
      
      sDatua := sIzena + '/' + sZenbakiUnitate + '.' + sZenbakiHamarreko;
      write(f2, sDatua);     (* Fitxategi batean idatzi *)   
   end;

   close(f1);    (* Fitxategiak itxi *)
   close(f2);
end;


procedure DatuakIkusi(sFitxIzen: tsKate250);
var
   f: tfsAgendaZahar;
   sDatua: tsKate30;
begin
   assign(f, sFitxIzen);
   reset(f);

   while not eof(f) do
   begin
      read(f, sDatua);
      writeln(FilePos(f)-1, '. posizioko datua: ', sDatua);
   end;

   close(f);    (* Fitxategia itxi *)
   writeln;
end;


{ ============================================================== }


var
   sAgendaIzen1, sAgendaIzen2: tsKate250;

begin
   write('1. agenda fitxategiaren izena eman: ');
   readln(sAgendaIzen1);
   
   write('2. agenda fitxategiaren izena eman: ');
   readln(sAgendaIzen2);
   
   DatuakSartu(sAgendaIzen1, sAgendaIzen2);
   writeln;
   
   writeln('1. agendaren datuak: ');
   DatuakIkusi(sAgendaIzen1);
   writeln;

   writeln('2. agendaren datuak: ');
   DatuakIkusi(sAgendaIzen2);
   writeln;

   { hemen idatzi ariketan eskatzen dena }

   writeln('Programa amaitzera doa');
   readln;
end.



Ariketen iturburu programak




Array datu-mota erabiliz
Fitxategien bitartez
 

13. astea | fitxategi beraren edukia modu desberdinez pantailaratzen








Demagun erregistroen fitxategi bat sortu dugula. Fitxategiaren elementu bakoitza erregistro bat da, eta erregistroak bi eremu ditu: lehena Integer datu-motakoa eta bigarrena Real datu-motakoa.
     trdIntReal = RECORD
                     Lehena   : integer ;
                     Bigarrena: real ;
                  END ;
Demagun sortutako fitxategiaren izena Zenbakiak.dat dela eta bere edukia datu-mota desberdineko fitxategien bitartez pantailaratzea nahi dugula. Eduki bera pantailaratzeko lau fitxategiren datu-motak erabiliko dira.

1


Zenbakiak.dat fitxategiaren edukia pantailaratzeko erabiliko dugun datu-mota DM_rdIntReal da, hots, sorrerako datu-mota berbera. Ondorioz, pantailaratuko den informazioa "jatorrizkoa" izango da. Adibidean:
1. eremuan 163 balioa eta 2. eremuan 1.1295338E+001 balioa.

2


Zenbakiak.dat fitxategiaren edukia pantailaratzeko erabiliko dugun datu-mota DM_rdRealInt da, jatorrizkoaren antzekoa baina eremuen datu-motak elkar trukaturik (lehena Real datu-motakoa eta bigarrena Integer datu-motakoa):
     trdRealInt = RECORD
                     Lehena   : real ;
                     Bigarrena: integer ;
                  END ;
Ondorioz, nahiz eta Zenbakiak.dat fitxategiaren edukia ez den aldatu, pantailaratuko den informazioa bestelakoa izango da. Adibidean:
1. eremuan 9.7150463E+302 balioa eta 2. eremuan 1076270902 balioa.

3


Zenbakiak.dat fitxategiaren edukia pantailaratzeko erabiliko dugun FILE datu-mota DM_fbyBytak da, hots, fitxategian BYTE datu-motako informazioa dagoela interpretatzen duen fitxategia. Horregatik, Zenbakiak.dat fitxategiaren edukia hainbat byten sorta delakoan, byte guztiak banan-banan pantailaratuko dira.


4


Zenbakiak.dat fitxategiaren edukia pantailaratzeko erabiliko dugun FILE datu-mota DM_fcKaraktereak da, hots, fitxategian CHAR datu-motako informazioa dagoela interpretatzen duen fitxategia. Horregatik, Zenbakiak.dat fitxategiaren edukia hainbat karakteren sorta delakoan, karaktere guztiak banan-banan pantailaratuko dira; bide batez, karaktere bakoitzaren ordinala ere erakusten da (3 urratseko informazio bera da).



Hona hemen, fitxategi beraren edukia modu desberdinez pantailaratzen duen programa:

{----------------------------------------------------------------
  Erregistroak gordetzen dituen "Zenbakiak.dat" fitxategia sortu 
  eta datu-mota desberdineko fitxategien bitartez atzitu.
 ----------------------------------------------------------------}

program Fitxategi_integerrealbytechar;

type
   tsKate99 = string[99];

   trdIntReal = record
                   Lehena   : integer;
                   Bigarrena: real;
                end;
 
   tfrdIntReal = file of trdIntReal;

   trdRealInt = record
                   Lehena   : real;
                   Bigarrena: integer;
                end;

   tfrdRealInt = file of trdRealInt;

   tfbyBytak = file of byte;

   tfcKaraktereak = file of char;

{--------------bakarra den fitxategia sortu--------------}
procedure INTEGER_REAL_FitxategiaSortu(sFitxIzen: tsKate99);
var
   f: tfrdIntReal;
   rdZenbakiak: trdIntReal;
   k, iZenbat: integer; 
begin
   assign(f, sFitxIzen);
   rewrite(f);
   
   write('Zenbat elementu nahi dituzu (2 elementu adibidez): ');
   readln(iZenbat);
   
   randomize;
   for k:=1 to iZenbat do
   begin 
      rdZenbakiak.Lehena := random(256);      (* byte baten balioak    *)
      rdZenbakiak.Bigarrena := random*100;    (* 0.0 eta 99.99 artekoa *)
      write(f, rdZenbakiak);
   end;
   
   close(f);
end;

{-----bakarra den fitxategia INTEGER_REAL bezala ikusi-----}
procedure INTEGER_REAL_FitxategiaIkusi(sFitxIzen: tsKate99);
var
   f: tfrdIntReal;
   rdZenbakiak: trdIntReal;
begin
   assign(f, sFitxIzen);
   reset(f);
   
   while not eof(f) do
   begin
      read(f, rdZenbakiak);
      writeln(filepos(f)-1, ' posizioan    1. eremua = ', rdZenbakiak.Lehena:3, '2. eremua = ':25, rdZenbakiak.Bigarrena:0:2);
   end;
   
   close(f);
end;

{-----bakarra den fitxategia REAL_INTEGER bezala ikusi-----}
procedure REAL_INTEGER_FitxategiaIkusi(sFitxIzen: tsKate99);
var
   f: tfrdRealInt;
   rdZenbakiak: trdRealInt;
begin
   assign(f, sFitxIzen);
   reset(f);
   
   while not eof(f) do
   begin
      read(f, rdZenbakiak);
      writeln(filepos(f)-1, ' POSIZIOAN    1. EREMUA =', rdZenbakiak.Lehena:12, '2. EREMUA = ':16, rdZenbakiak.Bigarrena:2);
   end;
   
   close(f);
end;

{-----bakarra den fitxategia CHAR bezala ikusi-----}
procedure CHAR_FitxategiaIkusi(sFitxIzen: tsKate99);
var
   f: tfcKaraktereak;
   cKarakterea: char;
   k: integer;
begin
   assign(f, sFitxIzen);
   reset(f);
   
   k:= 0;
   while not eof(f) do
   begin
      read(f, cKarakterea);
      k := k + 1;
      writeln(k:3, '. elementua = |', cKarakterea, '|    ', Ord(cKarakterea):3);
   end;
   
   close(f);
end;

{-----bakarra den fitxategia BYTE bezala ikusi-----}
procedure BYTE_FitxategiaIkusi(sFitxIzen: tsKate99);
var
   f: tfbyBytak;
   byByte: byte;
   k: integer;
begin
   assign(f, sFitxIzen);
   reset(f);
   
   k:= 0;
   while not eof(f) do
   begin
      read(f, byByte);
      k := k + 1;
      writeln(k:3, '. elementua = ', byByte:3);
   end;
   
   close(f);
end;

var {---------------------- Programa Nagusiko aldagaiak ---------------}
   sFitxIzen: tsKate99;

begin {--------------------------- Programa Nagusia -------------------}
   
   { sFitxIzen := 'C:\Datuak\Zenbakiak.dat';
     writeln('Fitxategi bitarraren izena: ', sFitxIzen); }
   
   sFitxIzen := 'Zenbakiak.dat'; 
   writeln('Fitxategi bitarraren izena: ', sFitxIzen);
   
   writeln;
   writeln('sizeof(tsKate99)   = ', sizeof(tsKate99):3, ' byte');
   writeln('sizeof(integer)    = ', sizeof(integer):3, ' byte');
   writeln('sizeof(real)       = ', sizeof(real):3, ' byte');
   writeln('sizeof(byte)       = ', sizeof(byte):3, ' byte');
   writeln('sizeof(char)       = ', sizeof(char):3, ' byte');
   writeln('sizeof(trdIntReal) = ', sizeof(trdIntReal):3, ' byte');
   writeln('sizeof(trdRealInt) = ', sizeof(trdRealInt):3, ' byte');
   writeln;
   writeln('RETURN sakatu aurrera egiteko!');
   readln;
   
   INTEGER_REAL_FitxategiaSortu(sFitxIzen);  { Lehen eremua integer }
   writeln;                                  { Bigarren eremua real }
   
   writeln('Zenbakiak.dat fitxategiaren edukia integer-real bezala azterturik:');
   writeln('------------------------------------------------------------');
   INTEGER_REAL_FitxategiaIkusi(sFitxIzen);
   writeln('------------------------------------------------------------');
   writeln;
   
   writeln('Zenbakiak.dat fitxategi bera real-integer bezala azterturik:');
   writeln('------------------------------------------------------------');
   REAL_INTEGER_FitxategiaIkusi(sFitxIzen);
   writeln('------------------------------------------------------------');
   writeln;
   
   writeln('Zenbakiak.dat fitxategi bera BYTE bezala azterturik:');
   writeln('------------------------------------------------------------');
   BYTE_FitxategiaIkusi(sFitxIzen);
   writeln('------------------------------------------------------------');
   writeln;
   
   writeln('Zenbakiak.dat fitxategi bera CHAR bezala azterturik:');
   writeln('------------------------------------------------------------');
   CHAR_FitxategiaIkusi(sFitxIzen);
   writeln('------------------------------------------------------------');
   writeln;
   
   writeln;
   writeln ('Programa amaitzeko RETURN tekla sakatu');
   readln;
   
end.   { PROGRAMAREN BUKAERA }
 

2024(e)ko apirilaren 12(a), ostirala

Fitxategiak: non gaude?








Fitxategi batekin lanean gaudela, hurrengo idazketa/irakurketa zein posiziotan gertatuko da? Beste era batera galdeturik, nola mugitu ahal dugu fitxategiak duen uneko posizioren erakuslea?

Demagun 4 elementuko fitxategi bat daukagula, adibidez hurrengo irudian ematen den zenbaki errealen fitxategia. Fitxategiaren posizioa zein den, eta posizio horri dagokion fitxategiaren elementua zenbatgarrena den kontzeptu desberdinak dira, nahiz eta biak elkar erlazionaturik dauden kontzeptu desberdinak dira. Adibidearen 4 elementuko fitxategiak dituen posizio posibleak 5 dira: 0, 1, 2, 3 eta 4. Eta 5 posizio horietatik, une jakin batean bakarra izango da jasango duen hurrengo idazketa/irakurketa operazioa.

Hurrengo idazketa/irakurketa operazioa fitxategiaren zein posiziotan gertatuko den guk geuk kontrolatu nahi badugu seek prozedura aplikatu beharko dugu. Gogora dakargun seek prozedura estandarra, zeinek bi parametro behar dituen:

  • fitxategia adierazten duen file datu-motako aldagaia
  • helburuko posizioa adierazten duen zenbaki osoa

Jarraian erakusten diren datu-mota eta aldagai hauek ditugula, horiei loturiko seek prozedura estandarraren dei desberdiak azalduko dira:

type
   tfrFitxategia = file of real ;
   tsKatea = string[199] ;

var
   f: tfiFitxategia ;        (* kopuru errealak biltzen dituen fitxategia *)
   rZbk_R: real ;            (* fitxategitik elementu bat irakurtzeko     *)
   rZbk_D: real ;            (* fitxategian elementu bat idazteko         *)
   liPosizioa: longint ;     (* fitxategiaren helburuko posizioa          *)
...

Seek prozeduraren bigarren parametroak har ditzaken balioak 0 eta filesize(f) artekoak izan daitezke (adibidean 0 eta 4 artekoak). Funtsean bi kasu daude:

  1. fitxategiaren filesize(f) bukaeran kokatzea, ala,
  2. fitxategiaren bukaeran ez den beste posizio batean kokatzea. Esate baterako, fitxategiaren lehen elementuaren gainean kokatzea edo fitxategiaren azken-aurreko posizioan kokatzea (fitxategiaren azken elementuaren gainean).


seek(f, filesize(f)) fitxategiaren bukaera

Fitxategiaren azken posizioan elementurik ez dago fitxategiaren bukaera delako. Fitxategiaren bukaeran kokaturik gaudela, ezin daiteke bertatik elementurik irakurri baina bai bertan elementu berri bat idatzi. Elementu berri bat idaztean fitxategiaren tamaina handituko da. Hurrengo adibide-programan ikusi I-A eta I-B kasuak.




seek(f, filesize(f)-1) fitxategiaren azken-aurreko posizioa

Fitxategiaren azken-aurreko posizioa fitxategiaren azken elementuarena da. Fitxategiaren azken-aurreko posizioan  kokaturik gaudela, bertako elementua irakur daiteke eta azken-aurreko posizio horretan idatz daiteke (noski, idazketa burutuko balitz elementu berriak aurrekoa ordezkatuko luke). Hurrengo adibide-programan ikusi II kasua.




seek(f, 0) fitxategiaren lehen posizioa

Fitxategiaren 0 posizioa fitxategiaren lehen elementuarena da. Fitxategiaren 0 posizioan  kokaturik gaudela, bertako elementua irakur daiteke eta 0 posizio horretan idatz daiteke ere (noski, idazketa burutuko balitz elementu berriak aurrekoa ordezkatuko luke). Hurrengo adibide-programan ikusi III kasua.




seek(f, filepos(f)-1) fitxategiaren uneko posizioaren aurrekoa

Fitxategiaren uneko posizioa filepos(f) funtzioaren bitartez ezagut daiteke. Fitxategiaren uneko posiziotik bat atzera egiteko seek(f, filepos(f)-1) agindua idatzi beharko da, jakinik exekuzio-denborako errorea gertatuko litzatekeela fitxategiaren uneko posizioa 0 bada (izan ere, fitxategiaren lehen elementuko aurrekorik ez dago). Hurrengo adibide-programan ikusi IV kasua.


Adibide-programa:

program SeekProzedura ;

uses
   sysutils ;    (* FileExists funtzioak behar duelako *)

const
   sBIDEA = 'C:\Datuak\' ;

type
   tfiFitxategia = file of real ;
   tsKatea = string[199] ;

procedure FitxategiaIkusi(sFitxIzen: tsKatea) ;
var
   f: tfiFitxategia ;
   rElementua: real ;
begin
   { uztartu }
   assign(f, sFitxIzen) ;
   reset(f) ;

   writeln('"', sFitxIzen, '" fitxategiak ', filesize(f), ' elementu ditu, bere edukia:') ;
   while not eof(f) do
   begin
      read(f, rElementua) ;
      writeln(rElementua:10:2) ;
   end ;
   writeln('.....................................................................') ;
   writeln ;
   { itxi }
   close(f) ;
end ;


procedure FitxategiaSortuEtaBete(sFitxIzen: tsKatea) ;
var
   f: tfiFitxategia ;
   rElementua: real ;
   i, kopurua: integer ;
begin
   { uztartu }
   assign(f, sFitxIzen) ;
   rewrite(f) ;

   write('Zenbat elementu nahi dituzu "', sFitxIzen, '" fitxategian? ') ;
   readln(kopurua) ;

   randomize; { random-aren hazia hasieratu }
   for i:=1 to kopurua do
   begin
      rElementua:=random*10 ;   { 0.0 eta 9.9 arteko zenbakia }
      write(f, rElementua) ;    { fitxategian idatzi eta hurrengo elementura pasa }
   end ;
   { itxi }
   close(f) ;
end ;


procedure FitxategiarenElementuBatProzesatu(sFitxIzen: tsKatea) ;
var
   f: tfiFitxategia ;        (* kopuru errealak biltzen dituen fitxategia *)
   rZbk_R: real ;            (* fitxategitik elementu bat irakurtzeko     *)
   rZbk_D: real ;            (* fitxategian elementu bat idazteko         *)
   liPosizioa: longint ;     (* fitxategiaren helburuko posizioa          *)
   cEragiketa: char ;        (* fitxategitik irakurri, fitxategian idatzi *)
   cBaiEz: char ;            (* fitxategiaren azken elementua aldatzeko   *)
begin
   assign(f, sFitxIzen) ;
   reset(f) ;

   repeat
      write('Helburuko posizioa eman (0 eta ', filesize(f), ' ) artekoa: ') ;
      readln(liPosizioa) ;
      if liPosizioa < 0 then
         writeln('Posiziorik txikiena 0 da') ;
      if liPosizioa > filesize(f) then
         writeln('Fitxategiaren bukaera ', filesize(f), ' da') ;
   until (liPosizioa >= 0) and (liPosizioa <= filesize(f)) ;

   repeat
      writeln('Fitxategiaren ', liPosizioa, ' posizioan dagoen elementuarekin zer nahi duzu egin?') ;
      write('Irakurri (R) edo idatzi (D)? ') ;
      readln(cEragiketa) ;
      cEragiketa := upcase(cEragiketa) ;
   until (cEragiketa = 'R') or (cEragiketa = 'D') ;

   writeln ;

   if cEragiketa = 'R' then   (* irakurketa fitxategitik *)
      if liPosizioa = filesize(f) then                             (* I-A kasua *)
         writeln(liPosizioa, ' posiziotik (fitxategiaren bukaeratik) ezin daiteke irakurri')
   else
   begin
      seek(f, liPosizioa) ;
      read(f, rZbk_R) ;
      writeln(rZbk_R:0:2, ' kopurua fitxategiaren ', liPosizioa , ' posizioan') ;
   end ;

   if cEragiketa = 'D' then   (* idazketa fitxategian *)
   begin
      write('Fitxategian idatziko den kopurua eman: ') ;
      readln(rZbk_D) ;

      if liPosizioa = filesize(f) then
      begin
         writeln(liPosizioa, ' posizioan (fitxategiaren bukaeran) idaztean elementu berri bat gehituko zaio fitxategiari') ;
         seek(f, liPosizioa) ;
         write(f, rZbk_D) ;                                        (* I-B kasua *)
      end
      else
      begin
         seek(f, liPosizioa) ;
         read(f, rZbk_R) ;
         writeln('Fitxategiaren ', liPosizioa , ' posizioan dagoen ', rZbk_R:0:2, ' kopurua galduko da') ;
         seek(f, filepos(f)-1) ;                                   (* IV kasua *)
         write(f, rZbk_D) ;
      end ;
   end ;

   seek(f, 0) ;                                                    (* III kasua *)
   writeln('"', sFitxIzen, '" fitxategiaren eduki berria:') ;
   while not eof(f) do
   begin
      read(f, rZbk_R) ;
      writeln(rZbk_R:10:2) ;
   end ;

   repeat
      write(filesize(f)-1, ' posizioko fitxategiaren azken elementua inkrementatu nahi (B/E)? ') ;
      readln(cBaiEz) ;
      cBaiEz := upcase(cBaiEz) ;
   until (cBaiEz = 'B') or (cBaiez = 'E') ;

   writeln ;

   if cBaiEz = 'B' then   (* irakurketa eta idazketa fitxategian *)
   begin
      seek(f, filesize(f)-1) ;                                     (* II kasua *)
      read(f, rZbk_R) ;
      rZbk_D := rZbk_R + 1 ;
      seek(f, filepos(f)-1) ;                                      (* IV kasua *)
      write(f, rZbk_D) ;

      seek(f, 0) ;                                                 (* III kasua *)
      writeln('"', sFitxIzen, '" fitxategiaren eduki berria:') ;
      while not eof(f) do
      begin
         read(f, rZbk_R) ;
         writeln(rZbk_R:10:2) ;
      end ;
   end ;

   close(f) ;
end ;


{============================PROGRAMA NAGUSIA============================}

var
   sIzena: tsKatea ;
begin
   writeln ;
   writeln ;
   writeln('"C:\Datuak" direktorioan lan eginez,') ;
   writeln('fitxategiaren izena eman ezazu (luzapenik gabe)...') ;
   write('Adibidez, "Kopuruak" izena: ') ;
   readln(sIzena) ;
   sIzena := sBIDEA + sIzena + '.dat' ;
   writeln ;

   if fileexists(sIzena) then
   begin
      writeln('"', sIzena, '" fitxategia existitzen da, lan egin dezagun.') ;
      writeln ;
      FitxategiaIkusi(sIzena) ;
      FitxategiarenElementuBatProzesatu(sIzena) ;
   end
   else
   begin
      writeln('"', sIzena, '" fitxategia ez da existitzen, sortuko dugu.') ;
      writeln ;
      FitxategiaSortuEtaBete(sIzena) ;
      FitxategiaIkusi(sIzena) ;
   end ;

   writeln ;
   writeln ('ENTER sakatu programaren exekuzioa amaitzeko...') ;
   readln ;
end.
 

FILE datu-mota


DEFINIZIOA

FILE datu-mota edo fitxategi datu-mota informazio homogeneo gordetzen duen bilduma bat da. Datu-mota bera duten osagaien multzo bat da fitxategia eta disko zein zintetan egon ohi da. Fitxategia diskoan identifikatzeko STRING bat erabiliko dugu.

Fitxategiek array linealekin zerikusia dutelako jarraian datu-mota biren arteko alderaketa egingo dugu:

Array datu-motaren eta Fitxategi datu-motaren arteko alderaketa

Array Fitxategi
Osagaiak Osagaiak datu-mota berekoak dira
Osagaiak datu-mota berekoak dira
Atzipena Osagai bat identifikatzeko dagokion indizea erabiltzerik dago Osagai bat identifikatzeko fitxategiak erakusle bat dauka barneraturik
Tamaina Luzera maximoa aurredefiniturik dago Ez dago zertan aldez aurretik luzera definitu beharrik
Euskarria Memorian kokatzen da Memoriatik kanpo kokatzen da

ESKEMA

Hona hemen zenbaki errealak gordetzen dituen array baten eta fitxategi baten eskemak:

Fitxategiaren eskeman agertzen den egituran, lehenengo kontroleko notak diruditen zenbaki errealak biltzen dira eta lehenago esan dugun bezala memoriatik kanpo aurkitzen da. Memoriatik kanpo dagoen egitura horri fitxategi fisiko deritzo eta hura lantzeko beharrezkoa da FILE datu-motako frFitxategia aldagaia, FILE datu-motako frFitxategia aldagaiari fitxategi logiko esaten zaio eta aldagai guztiak bezala memorian kokaturik aurkitzen da.
DATU-MOTA SORTZEN

Zenbaki errealak gordetzeko fitxategiekin lan egiteko, lehenik FILE datu-mota bat deklaratuko dugu eta gero frFitxategia aldagaia sortuko dugu. Baina, diskoan dagoen fitxategiak izen bat du eta horregatik STRING bat erabili beharko dugu ere:
...
   type
      tfrFitxategia = file of real ;
      tsKateLuzea   = string[199] ; 
   var
      frFitxategiBat: tfrFitxategia ;  { fitxategi logikoa          }
      sFitxIzenBat  : tsKateLuzea ;    { fitxategi fisikoaren izena }
...      

Zein datu-motako elementuak izan ditzake fitxategiak? Edozein datu-motako elementuak gorde ditzake fitxategi batek? Bai eta ez.

Jarraian ematen diren definizioak zuzenak dira:
...
   type
      tfiOsoak = file of integer ;          { osoen fitxategia         }
      tfrErrealak = file of real ;          { errealen fitxategia      }
      tfboBoolearrak = file of boolean;     { boolearren fitxategia    }
      tfcKaraktereak = file of char ;       { karaktereen fitxategia   }
      tfsKateak = file of tsKate125 ;       { kateen fitxategia        }
      tfaiArrayak = file of taiElem ;       { osoen arrayen fitxategia }
      tfrdErregistroak = file of trdElem ;  { erregistroen fitxategia  }
...      

Baina hemen ematen diren bi datu-motetatik bigarrena okerra da, fitxategi batek ezin duelako beste fitxategi bat barneratu:
...
   type
      tfrErrealak = file of real ;            { errealen fitxategia }
      tffFitxategiak = file of tfrErrealak ;  { HAU EZIN DA         }
...      

FITXATEGI LOGIKOA ETA FITXATEGI FISIKOA

Zenbaki errealak gordetzeko fitxategiekin lan egiteko, lehenik FILE datu-mota bat deklaratuko dugu eta gero frFitxategia aldagaia sortuko dugu. Baina, diskoan dagoen fitxategiak izen bat du eta horregatik STRING bat erabili beharko dugu ere:
...
   type
      tfrFitxategia = file of real ;
      tsKateLuzea   = string[199] ; 
   var
      frFitxategiBat: tfrFitxategia ;  { fitxategi logikoa          }
      sFitxIzenBat  : tsKateLuzea ;    { fitxategi fisikoaren izena }
...      

Diskoan dagoen informazioa atzitu ahal izateko sFitxIzenBat aldagaia erabiliko dugu eta fitxategiarekin lan egiteko frFitxategiBat aldagaia (FILE datu-motatakoa) beharko dugu. Bi aldagaiak, noski, konputagailuaren memorian kokatzen dira. Baina, diskoan dauden fitxategiaren datuak ez dira kokatzen konputagailuaren memorian.

Diskoan kokaturik dagoen egiturari fitxategi fisiko esango diogu. Adibidez, zenbaki errealak biltzen dituen Datuak.dat izeneko egiturari fitxategi fisiko esaten diogu eta hona hemen bere balizko eskema bat:

Fitxategi logikoa adierazten duen frFitxategiBat aldagaia eta diskoan dagoen fitxategi fisikoa elkar uztartzeko assign prozedura daukagu, eta elkarketa egiteko fitxategi fisikoaren izenaren bitartez lortzen da, STRING baten bitartez alegia. Demagun sFitxIzenBat aldagaiaren edukia 'Datuak.dat' balioa dela. Ikusi eskema hauetan assign(frFitxategiBat,sFitxIzenBat) prozedura aplikatu aurreko egoera eta prozedura aplikatu ondoko egoera:
OINARRIZKO ERAGIKETA: FITXATEGITIK IRAKURRI

Fitxategi fisikoan, diskoan, dagoen datu bat memoriara ekartzeko irakurketa bat egin behar da. Demagun frFitxategiBat aldagaia (FILE datu-motatakoa) daukagula eta assign(frFitxategiBat, sFitxIzenBat) bitartez uztartu egin dugula 'Datuak.dat' izena duen diskoko fitxategiarekin.

FILE datu-motako frFitxategiBat aldagaia behar da Datuak.dat fitxategitik datu bat irakurtzeko:
read(frFitxategiBat, rElem);      readln(frFitxategiBat, rElem);
Non rElem memorian dagoen aldagaia den eta fitxategiko datua jasoko duen. Ikusi eskema:

Irakurketa bakoitzeko elementu bakar bat irakur daiteke, fitxategiaren erakusleak adierazten duen elementua hain zuzen ere. Irakurketa gertatu ondoren erakusleak aurrera egiten du.
OINARRIZKO ERAGIKETA: FITXATEGIAN IDATZI


Memorian dagoen datu bat diskoan gordetzeko, idazketa bat egin beharko da diskoan. Demagun lehen bezala, daukagun frFitxategiBat aldagaia uztartu dugula 'Datuak.dat' izena duen diskoko fitxategiarekin. Memorian aurkitzen den rElem aldagaian 7.05 datua dago.

Honela idazten da datu hori fitxategi batean, lehen bezala frFitxategiBat aldagaiaren bitartez:
write(frFitxategiBat, rElem);      writeln(frFitxategiBat, rElem);
Memorian dagoen rElem aldagaiaren edukia fitxategian idatzi. Ikusi eskema:

Hasieran, fitxategia hutsik egon da (fitxategiaren amaierako marka 0 posizioan dagoelako) horregatik fitxategiaren erakuslea 0 posizioan kokaturik egon da. Idazketa burutu ondoren, datu berri bat dago fitxategian eta erakusleak aurrera egiten du 1 posizioan kokatuz.

rElem aldagaiaren edukia berriztuz eta bigarren idazketa bat eginez gero, egoera honako hau izango litzateke, ikusten denez fitxategia luzatu egiten da elementu berri bat daukalako:

Baina hirugarren idazketa bat egin aurretik fitxategiaren erakuslea tokiz aldatzen badugu (horretarako seek prozedura erabili behar da), adibidez dagoen tokitik bat atzera egin dezala erakusleak, orduan idazketaren emaitza bestelakoa da. Izan ere, fitxategiaren elementua ordezkatzen du fitxategia luzatu gabe. Beraz, hau da erakuslea posizio bat atzeratzeko agindua seek(frFitxategiBat, filepos(frFitxategiBat)-1) eta hurrengo idazketa burutu aurretiko egoera irudi honetan erakusten da:

Hurrengo idazketa gauzatu osteko irudia:

Ikusten da rElem aldagaiaren edukia berria 5.91 dela eta erakusleak posizio bat atzera egin duela (2-tik 1 posiziora). Idazketa orain burutzean, elementu berria 1 posizioan gordeko da.

Idazketa burutu ondoren: elementu berriak zaharra ordezkatu du, erakusleak aurrera egin du (2 posizioan kokatuz), eta, ondorioz fitxategiaren luzera ez da aldatu.

Ikusi ere Fitxategiak: non gaude? artikulua.
LAN EGITEKO BALIABIDEAK

Fitxategiekin trebatzeko adibide-ariketa batzuk prestatu dira. Adibide-ariketak bederatzi dira eta exekutatu aurretik agindu hauek jarraitu:
  1. Iturburu-programak horiek bederatzi dira eta osoen fitxategiekin lan egiten dute
  2. Iturburu-programak zenbatuta daude eta zenbakiek adierazten duten sekuentzia gordez iturburu-programak konpilatu, exekutatu eta emaitzak interpretatu
  3. Jarraian ematen diren bederatzi adibide-programak hartu eta direktorio batean gorde, edozein karpetatan gorde dezakezu, adibidez Programak delako direktorioan
  4. Iturburu-programak konpilatzean Programak direktorio horren barruan sortuko dira programa exekutagarriak
  5. C: diskoaren erroan NereDatuak izeneko karpeta bat sortu, non datu-fitxategiak egongo diren, adibidez C:\NereDatuak\Zenbakiak.dat datu-fitxategia
Adibide-ariketak:
  • 1FitxategianGorde.pas fitxategi bat sortu rewrite prozeduraren bitartez, hamar datu idatzi fitxategian, eta bukatzeko fitxategiaren edukia pantailaratu
  • 2FitxategiaIrakurri.pas existitzen den fitxategia zabaldu reset prozeduraren bitartez, eta dituen hamar elementuak pantailaratu
  • 3FitxategiarenExistentzia.pas fitxategi existitzen den ala ez aztertu fileexists funtzioa erabiliz, funtzio honek sysutils unitatea behar du, horregatik programaren hasieran uses sysutils agindua derrigorrezkoa da
  • 4FitxategiaEOF.pas fitxategiaren erakuslea fitxategiaren bukaeran dagoenean eof funtzio boolearrak TRUE itzultzen du, End Of File egia baita
  • 5FitxategiaSeekFilePos.pas hurrengo idazketa ala irakurketa fitxategiaren zein posiziotan gertatuko den Seek prozedura eta filepos funtzioarekin bermatuko dugu, fitxategiak zenbat elementu dituen ezagutzeko filesize funtzioa erabil daiteke (gogoratu Fitxategiak: non gaude? artikulua)
  • 6FitxategiaMoztu.pas zabalik aurkitzen den fitxategia moztu truncate prozeduraren bitartez, erakusleak adierazten duen posiziotik aurrerako datuak galduz
    procedure FitxategiaMoztu(sFitxIzen: tsKatea);
    var
       fFitxategia: tfFitxategia;
       iPosizioa  : integer;
    begin
       assign(fFitxategia, sFitxIzen);
       reset(fFitxategia);
    
       repeat
          writeln(sFitxIzen,
                  ' fitxategiaren datuen indizeak: 0..',
                  FileSize(fFitxategia)-1);
    
          write('Zein elementutik moztu nahi duzu? ');
          readln(iPosizioa);
       until (iPosizioa >= 0) and
             (iPosizioa <= FileSize(fFitxategia)-1);
    
       seek(fFitxategia, iPosizioa);    { mozteko kokatu   }
       truncate(fFitxategia);           { fitxategia moztu }
    
       close(fFitxategia);              { fitxategia itxi  }
    end;

  • 7FitxategiaEzabatu.pas itxita aurkitzen den fitxategia ezabatu erase prozeduraren bitartez, fitxategia diskotik ezabatuko da
    procedure FitxategiaEzabatu(sFitxIzen: tsKatea);
    var
       fFitxategia: tfFitxategia;
    begin
       assign(fFitxategia, sFitxIzen);  { fitxategia uztartu }
                                        { baina ez ireki     }
       erase(fFitxategia);              { fitxategia itxita  }
    end;                                { dagoenez ezabatu   }

  • 8FitxategiaBerrizendatu.pas itxita aurkitzen den fitxategiari bere izena aldatu rename prozeduraren bitartez, fitxategia diskotik ez da desagertuko baina izen berri bati esker atzitu ahalko dugu
    procedure FitxategiaBerrizendatu(sFitxIzenZahar: tsKatea;
                                     sFitxIzenBerri: tsKatea);
    var
       fFitxategia: tfFitxategia;
    begin
       assign(fFitxategia, sFitxIzenZahar);  { fitxategia uztartu    } 
                                             { baina ez ireki        } 
       rename(fFitxategia, sFitxIzenBerri);  { fitxategia itxita     } 
    end;                                     { dagoenez berrizendatu } 

  • 9FitxategiakEtaParametroak.pas prozedura eta funtzioetara fitxategiaren izena pasatuko da; azpiprograman definituko da file datu-motatako aldagaia, azpiprogramaren hasieran assign egingo da, gero reset/rewrite (bietariko bat, egoerari dagokiona), gero datuekin lan egingo da (read/write) eta azpiprogramaren azkenean fitxategia itxi beharko da close bat erabiliz
FITXATEGIAK PARAMETRO BEZALA

Fitxategiak lantzen dituen errutinak idaztean aukera bi izango ditu programatzaileak, fitxategi logikoa bidaltzea azpiprogramara (file datu-motako aldagaia) edo bestela fitxategi fisikoaren izena igortzea azpiprogramara (string datu-motako aldagaia).

Guk bigarren bidea erabiliko dugu, hots, azpiprogrametara fitxategi fisikoaren izena bidaliko dugu string aldagai baten bitartez. Kontutan izan dezagun, nahiz eta azpiprogramaren barruan fitxategia aldatua izan, bere izena aldatzen ez den bitartean parametroa sarrerakoa izango dela (baliozko parametroa alegia).


Azpiprogrametan fitxategiekin lan egiteko hiru urrats emango dira:
  1. Fitxategi logikoa eta fitxategi fisikoa assign bitartez elkartu, gero fitxategia ireki reset (edo rewrite) prozedura erabiliz
  2. Idazketa edo/eta irakurketa operazioak burutu (write edo/eta read prozedurak)
  3. Fitxategia itxi close bitartez itxi



Fitxategiaren izena kate bat da eta gogoratu string datu-mota sinplea dela. Horregatik, azpiprograma batean honela agertuko da jokamoldearen arabera:
  • Fitxategiaren izena irteerakoa denean var marka izango du aurrean
  • Fitxategiaren izena sarrerakoa denean ez du inolako markarik izango
    FITXATEGIEN GAINEKO ERAGIKETAK

    Hurrengo puntuetan fitxategien gaineko zenbait eragiketa azalduko dugu, eragiketok beti azpiprogrametan gauzatuko ditugu eta horrela programa konplexu batetarako oinarrizko software zatiak izan daitezke.

    Erregistroen fitxategiak landuko ditugu. Beraz hemendik aurrera honelako definizioa sarritan ikusiko dugu, non fitxategiaren elementuaren oinarria hiru eremuko erregistroa den:

    type 
       tsKate49 = string[49];
       trdFitxa = record
                     sIzenDeiturak: tsKate49;
                        byDeialdia: byte;
                             rNota: real;
                  end;
       tfrdFitxategi = file of trdFitxa;          










    Hiru eremu dira eta aurrerago ikusiko dugunez, haien arteko ordena erlatiboa garrantzizkoa da. Hau da, lortzen den datu-fitxategiaren elementu bakoitza tsKate49-byte-real ordena hori jarraituz gordetzen da fitxategian.




    FITXATEGIA SORTU

    FitxategiaSortu.pas adibidean fitxategi berri bat sortu eta trdFitxa datu-motako erregistroak fitxategian gordetzen dira.



    FITXATEGIAREN EXISTENTZIA

    FitxategiaSortuFitxategiaIkusi.pas adibidean existitzen ez den fitxategia sortzen da, ala prozesatu egiten da lehendik existitzen bazen. Gogoratu ere lehenago ikusi dugun 3FitxategiarenExistentzia.pas adibidea eta 9FitxategiakEtaParametroak.pas adibidea non fitxategi baten existentzia aztertzen den fileexists funtzioa erabiliz.



    FITXATEGI OSOA PROZESATU

    Fitxategiaren elementu guztiei eragiketa bera aplikatzen zaion kasua da hau, adibidez:
    • FitxategiOsoaProzesatu1.pas adibidean existitzen den fitxategi baten edukia erakusten da
    • FitxategiOsoaProzesatu2.pas adibidean fitxategiaren elementu guztien byDeialdia datuak unitate batean inkrementatzen dira
    • FitxategiOsoaProzesatu3.pas adibidean fitxategi baten informazioa beste bi fitxategi berrien artean banatzen da: 1. deialdiko ikasleak Berriak.DAT fitxategira eta gainerakoak Besteak.DAT fitxategira
    • FitxategiOsoaProzesatu4.pas adibidean fitxategiaren nota maximoa duen elementuaren posizioa zehazten da, ondoren nota maximoa lortu duen ikaslearen datuak pantailaratzen dira



    BILAKETA FITXATEGIAN

    BilaketaFitxategian.pas izeneko adibidean sIzenDeiturak eremuari dagokion datu bat irakurtzen da programa nagusian, ondoren prozedura batean datu horren bilaketa gauzatzen da, non prozeduraren irteerako parametroa erregistro bat den. Prozeduran barruan datua bilatzen bada erregistroa itzuliko da programa nagusira, eta datua aurkitzen ez bada markaren bat itzuliko zaio programa nagusiari (adibidez -1.0 marka).

    Bilaketaren deia arrayetan, programa nagusian izena ezaguna da eta beste biak nahi dira (deialdia eta nota):
    ...
      iIndizeaNon := fniBilatu(ardGela, 
                               iLuzera,
                               sGakoa);  { ardGela arrayan sGakoa bilatu }
      if iIndizeaNon = -1 then
         writeln(sGako, ' izeneko ikaslerik ez dago')
      else
      begin
         writeln('Deialdia: ', ardGela[iIndizeaNon].byDeialdia);
         writeln('    Nota: ', ardGela[iIndizeaNon].rNota:0:2);
      end;
    ...      
    

    Bilaketaren deia fitxategietan, programa nagusian izena ezaguna da eta beste biak nahi dira (deialdia eta nota):
    ...
      Bilatu(sFitxIzen, sGakoa, rdElem);  { sFitxIzen fitxategian sGakoa bilatu }
    
      if rdElem.rNota = -1.0 then
         writeln(sGako, ' izeneko ikaslerik ez dago')
      else
      begin
         writeln('Deialdia: ', rdElem.byDeialdia);
         writeln('    Nota: ', rdElem.rNota:0:2);
      end;
    ...      
    

    Bilaketaren deia fitxategietan, programa nagusian izena ezaguna da eta elementuaren posizioa fitxategian nahi da:
    ...
      iNonDago := fniBilatu(sFitxIzen, sGako);  { sFitxIzen fitxategian sGakoa bilatu }
    
      if iNonDago = -1 then
         writeln(sGako, ' izeneko ikaslerik ez dago')
      else
         writeln(sGako, ' izeneko ikaslea ', iNonDago, ' posizioan dago');
    ...      
    



    GEHIKETA FITXATEGIAN

    GehiketaFitxategian.pas izeneko adibidean fitxategi bati elementu berri bat gehitzen zaio (fitxategiaren bukaeran, noski).



    FITXATEGIAREN DATU BATEN ALDAKETA

    DatuBatenAldaketa.pas izeneko adibidean ikasle bati dagokion rNota eremuko balioa aldatu behar zaio. Lehenik, aldatu behar den elementuaren bilaketa egiten da eta gero aldaketa gauzatzen da. Baina kontuz, nahiz eta elementuaren eremu bakarra aldatu nahi izan, fitxategitik irakurtzean edo fitxategian idaztean elementu osoa prozesatzen da.



    FITXATEGIAN ELEMENTU BAT TARTEKATU

    Eragiketa hau egiteko array laguntzaile bat erabiliko dugu (ikusi hurrengo bi atalak: F→A eta A→F). Gogoratu arrayen algoritmoak, konkretuki Txertaketa (arrayaren k posizio ezagun batean elementu berri bat txertatu edo tartekatu). Hauxe da DatuBatenTxertaketa.pas izeneko adibidea.



    FITXATEGITIK ELEMENTU BAT KENDU

    Kendu beharreko elementua azkena bada truncate prozedura aplika dezakegu, gainerako kasuetan array laguntzaile bat erabiliko dugu (ikusi hurrengo bi atalak: F→A eta A→F). Bi bide:
    1. Gogoratu arrayen algoritmoak, konkretuki Ezabaketa (arrayaren k posizio ezagun batean dagoen elementua ezabatu). Hauxe da DatuBatenEzabaketa.pas izeneko adibidea
    2. F→A prozesua egitean kendu behar dugun elementua ez pasatu fitxategitik arrayra. Hauxe da DatuBatenEzabaketaErrazagoa.pas izeneko adibidea



    FITXATEGITIK ELEMENTU BATZUK KENDU

    Kendu beharreko elementuek baldintza bera betetzen dute. F→A prozesua egitean kendu behar ditugun elementuak saihestu (ez pasatu) fitxategitik arrayra. Hauxe da DatuBatzuenEzabaketa.pas izeneko adibidea.



    FITXATEGI BAT SAILKATU/ORDENATU
    HAU EZ. Ez da azterketan galdetuko baina proiektuan erabil daiteke.

    Eragiketa hau egiteko array laguntzaile bat erabiliko dugu (ikusi hurrengo bi atalak: F→A eta A→F). Gogoratu arrayen elementuen Sailkatzea/Ordenatzea nola lortzen zen. Hona hemen bi adibide:
    • Sailkatze arrunta eremu bakar baten arabera. FitxategiaSailkatu.pas izeneko adibidean fitxategia rNota eremuaren arabera sailkatzen denez nota baxuena duten erregistroak fitxategiaren hasieran kokatzen dira eta nota altuko erregistroak fitxategiaren bukaeran egongo dira
    • Sailkatze aurreratua (bi eremuen araberakoa). FitxategiaSailkatu_SailkatzeAurreratua.pas izeneko adibidean fitxategia byDeialdia eremuaren arabera sailkatzen da, eta deialdi berdina duten bi erregistroen kokapena erabakitzeko sIzenDeiturak eremuari begiratzen zaio ordena alfabetikoa zainduz. Gauza bera egiten da FitxategiaSailkatu_2EremukoSailkatzeAurreratua.pas izeneko adibidean



    FITXATEGI → ARRAY

    F → A algoritmoan informazioa diskoko fitxategi batean dago eta memoriako array batera eraman nahi da. Ikusi FitxategitikArrayra.pas programa non C:\Tokia\ karpetako fitxategi batetik abiatuta memoriako array bat elikatzen duen. Programaren zatirik interesgarriena prozedura hau da:

       procedure FitxategiArray(var ardGela: tardZerrenda;   
                                var iLuzera: integer; 
                                  sFitxIzen: string);
       var
          f     : tfrdFitxategi;
          rdElem: trdFitxa;
       begin
          assign(f, sFitxIzen);
          reset(f);
    
          iLuzera := 0;
          while not eof(f) do
          begin         
             read(f, rdElem);
             iLuzera := iLuzera +1;
             ardGela[iLuzera] := rdElem;
          end;
    
          close(f);
       end;          
    

    Fitxategia ireki eta fitxategia bukatzen ez den bitartean, itzuli bakoitzeko, elementu bat fitxategitik irakurri eta memorian dagoela arrayean gorde.

     

     

     

     

     




     

     

     

     

     

     




    ARRAY → FITXATEGI

    A → F algoritmoan informazioa memoriako array batean daukagu eta diskoko fitxategi batera igaro nahi da. Aurreko F→A programa ikusirik, erraz ulertzen da array batean daukagun informazioa fitxategi batera eramateko prozedura hau:

       procedure ArrayFitxategi(const ardGela: trdZerrenda;  
                                      iLuzera: integer; 
                                    sFitxIzen: string);
         var
            f       : tfrdFitxategi;
            rdElem  : trdFitxa;
            iIndizea: integer; 
         begin
            assign(f, sFitxIzen);
            rewrite(f);
    
            for iIndizea:=BEHEMUGA to iLuzera do
            begin
               rdElem := ardGela[iIndizea];
               write(f, rdElem);
            end;
    
            close(f);
         end;
    


    FitxategitikArrayra.pas programari A → F algoritmoa gehitu zaio, eta FitxategiArrayFitxategi.pas programa berri honek array baten informazioa C:\Tokia\ karpetako fitxategi batean gordetzen da.

    FitxategitikArrayra.pas programari A → F algoritmoa gehitu zaio, eta FitxategiArrayFitxategi.pas programak eskema honi jarraitzen dio F → A → F non algoritmoak hasieran fitxategitik arrayra darama informazioa (edo informazioaren zati bat) eta ondoren arraytik fitxategira dakar berriro.
    DATU-FITXATEGI BAT LANTZEKO PROGRAMAK (I)

    Landu edo prozesatu nahi dugun fitxategiaren barne egitura eta fitxategi horri dagokion programaren datu-motak elkar estuki lotuta daude. Ezin da edozein fitxategi edozein programaren bitartez prozesatu. Hiru iruditan azal dezagun.

    0.
    C:\31_Taldea.dat datu-fitxategiarekin lan egingo dugu, eta ondoko programek prozesuatuko dute C:\31_Taldea.dat datu-fitxategia:

    1.
    Esate baterako, har eta exekuta dezagun gorago erakutsi den FitxategiaSortu.pas programa zeinek honelako egituradun fitxategia sortzen duen:
      type 
         tsKate49 = string[49];
         trdFitxa = record
                       sIzenDeiturak: tsKate49;
                          byDeialdia: byte;
                               rNota: real;
                    end;
         tfrdFitxategi = file of trdFitxa;          
    Ondoko irudian ikusten da FitxategiaSortu.pas programaren balizko exekuzio bat, non C:\31_Taldea.dat izeneko fitxategian hiru ikasleen datuak gordetzen diren:

    2.
    Orain gorago ikusitako FitxategiOsoaProzesatu1.pas programaren bitartez C:\31_Taldea.dat izeneko fitxategi hori prozesatuko dugu. Ez ahaztu FitxategiOsoaProzesatu1.pas programak dituen datu-motak hauexek direla:
      type 
         tsKate49 = string[49];
         trdFitxa = record
                       sIzenDeiturak: tsKate49;
                          byDeialdia: byte;
                               rNota: real;
                    end;
         tfrdFitxategi = file of trdFitxa;          
    Programaren datu-motak eta fitxategiaren barne egitura bat datoz, horregatik FitxategiOsoaProzesatu1.pas programaren exekuzioak egoki erakusten du C:\31_Taldea.dat izeneko fitxategian edukia:

    3.
    Gorago ikusitako FitxategiOsoaProzesatu1.pas programari aldaketa txiki bat egingo diogu FitxategiOkerraOsokiProzesatu.pas deituz. Programa bien arteko aldea bi eremuen ordenan datza (lehenik rNota eta ondoren byDeialdia). Programa berriak dituen datu-motak hauexek dira:
      type 
         tsKate49 = string[49];
         trdFitxa = record
                       sIzenDeiturak: tsKate49;
                               rNota: real;
                          byDeialdia: byte;
                    end;
         tfrdFitxategi = file of trdFitxa;          
    Ondorioz FitxategiOkerraOsokiProzesatu.pas programa exekutatzean eta C:\31_Taldea.dat fitxategia erakustean ondoko hau agertuko da:

    Goiko irudian argi dago emaitza okerra dela. Zergatik?  C:\31_Taldea.dat izeneko fitxategiaren barne egitura eta FitxategiOkerraOsokiProzesatu.pas programaren datu-motak bat ez datozelako.
    DATU-FITXATEGI BAT LANTZEKO PROGRAMAK (II)

    Ikusi dugu prozesatu nahi dugun fitxategiaren barne egitura eta dagokion programaren datu-motak elkar estuki lotuta daudela. Baina zer neurriraino? Jarraian datu-moten identifikadoreak mintzagai ekarriko ditugu, erakutsiko dugu datu-moten identifikadoreen izenak garrantzitsuak ez direla. Hots, erregistro baten eremuen ordena zaintzea ezinbestekoa dela; horrez gain, ezinbestekoa direla ere datu-moten tamainak eta izaerak. Erregistroekin ari garela, bere eremuen ordena eta datu-motak berdin-berdinak izan behar dira fitxategiaren barne egituran eta hura prozesatzeko programaren datu-motetan.

    Lehen bezala hiru iruditan azalduko dugu. Lehen bi irudien datu-motak berdinak dira eta hirugarren irudirako datu-moten identifikadoreak moldatu ditugu.

    1. eta 2.
    Jarraian erakusten dira FitxategiaSortu.pas programak zer datu-motak erabiltzen dituen, eta FitxategiOsoaProzesatu1.pas programak datu-mota berberak erabiltzen dituenez C:\31_Taldea.dat izeneko fitxategiaren edukia bistaratzeko ez da arazorik izango. Guk aukeratutako identifikadoreak beltzez adierazi ditugu:
      type 
         tsKate49 = string[49];
         trdFitxa = record
                       sIzenDeiturak: tsKate49;
                          byDeialdia: byte;
                               rNota: real;
                    end;
         tfrdFitxategi = file of trdFitxa;          
    Ondoko bi irudietan ikusten da FitxategiaSortu.pas programaren balizko exekuzio bat eta FitxategiOsoaProzesatu1.pas programaren exekuzioa, non C:\31_Taldea.dat izeneko fitxategiaren edukia zuzentasunez pantailaratzen den:



    3.
    FitxategiOsoaProzesatu1.pas programa aldatuko dugu FitxategiOsoaProzesatu1_ALDATUA.pas sortuz. Aldaketaren zioa identifikadore berriak asmatzea da, honako hauek aukeratu ditugu:
      program FitxategiOsoaProzesatu1_ALDATUA;
      type 
         tsKate99 = string[99];
         tsKate49 = string[49];
         trdFitxa = record
                                    sNor: tsKate49;
                       byDeialdiZenbakia: byte;
                           rKalifikazioa: real;
                    end;
         tfrdFitxategi = file of trdFitxa;          

    Identfikadore berrien datu-motak irudi honetan jaso dira:

    FitxategiaSortu.pas programaren bitartez C:\31_Taldea.dat izeneko fitxategia sortu ondoren FitxategiOsoaProzesatu1_ALDATUA.pas exekutatu eta datuak ondo ikusiko dira:

    FITXATEGI TALDE BAT PROZESATU
    HAU EZ. Ez da azterketan galdetuko, baina proiektuan erabil daiteke.

    Demagun 5 fitxategi prozesatu behar ditugula eta landu behar ditugun fitxategi horien izenak Datuak_XY.dat itxurakoak diren, non XY digituak diren. Adibidez, landu behar ditugun fitxategiak hauek izan daitezke: Datuak_01.dat, Datuak_02.dat, Datuak_03.dat, Datuak_04.dat eta Datuak_05.dat.

    Esan dugunez, talde horretako fitxategi bakoitzari prozesaketa bera aplikatu behar diogu. Adibidez, suposatu taldeko fitxategi bakoitzaren azken elementua ezabatu nahi dela. Hementxe ematen da ariketa horren programa:



    Aurreko kasuan fitxategien izenak antolaketa bat daukate, baina gerta daiteke fitxategien izenek legerik ez jarraitzea. Bigarren kasu honetan fitxategien taldea beste modu batez osatu beharko da. Esate baterako, taldea osatzen duten fitxategien izenak array batean gorderik egon daizteke, adibide honetan bezala:

    Diskoarekin lan egiteko:

    • GetCurrentDir funtzioa, ez du parametrorik behar eta uneko direktorioa itzultzen du karaktere-kate batean 
    • Chdir prozedura, karaktere-kate bat hartzen du sarrerako parametrotzat eta uneko direktorio aldatzen du, uneko direktorio berria karaktere-kateak adierazitakoa izango da



    • diskoa unitatea, 33. Ariketa: unitateak (III) adibidean ikus daitekeen bezala bi zeregin betetzeko balio du: 
      1. DirektorioarenEdukia prozedurak direktorio baten edukiaren informazioa (fitxategiak eta direktorioak) pantailaratzen du, karaktere-kate bat behar du fitxategien izenek bete behar duten moldea adierazten duen karaktere katea
      2. FitxategienIzenak prozedurak direktorio baten fitxategien izenak array batean itzultzen ditu


    DATU-FITXATEGIAK NON SORTZEN DIRA?
    HAU EZ. Ez da azterketan galdetuko, baina jakin behar da.

    Azalpen hauek Direktorioak: Non gaude? artikuluan eman dira ere.

    Datu-fitxategia sortzeko fitxategiaren izenari erreparatzen zaio eta bi egoera izan daitezke. Bat, fitxategiaren izena ematean diskoaren kokapen zehaztu izana, adibidez C:\Tokia\Datuak.dat non Tokia karpeta aldez aurretik sorturik egon behar den. Bi, fitxategiaren izena ematean diskoaren kokapenik ez den zehazten, adibidez Datuak.dat non karpetarik ez den adierazi. Egoera biak ikus ditzagun:

    1.
    Fitxategiaren izena ematean C:\Tokia\Datuak.dat katea erabili bada, orduan C: diskoaren erroaren \ menpe dagoen Tokia izeneko karpetan sortuko da Datuak.dat fitxategia. Ikusi esate baterako 1FitxategianGorde.pas adibidea.

    2a.
    Fitxategiaren izena ematean Datuak.dat katea erabili bada eta Dev-Pas programazio-ingurunea erabilita iturburu-programa konpilatzen badugu programa exekutagarria eskuratuko dugu;  Dev-Pas programazio-ingurunetik irten gabe programa exekutagarria exekutatzen badugu, orduan Datuak.dat fitxategia Dev-Pas programazio-ingurunearen direktorioan sortuko da, adibidez C:\Dev-Pas karpetan. Ikusi FitxategiaSortu_BiderikGabe_IngurunetikExekutatzen.pas adibidea.
    C:\KarpetaBat direktorioan gaudela .PAS iturburu-programa konpilatu
    eta .EXE programa exekutagarria lortuko da C:\KarpetaBat karpetan

    Programazio-ingurune barrutik .EXE programa egikaratzean Datuak.dat
    fitxategia C:\Dev-Pas direktorioan sortuko da biderik ez bada zehaztu

    2b.
    Fitxategiaren izena ematean Datuak.dat katea erabili bada eta Dev-Pas programazio-ingurunea erabilita iturburu-programa konpilatzen badugu programa exekutagarria eskuratuko dugu, adibidez FitxategiaSortu_BiderikGabe_ExekutagarriaExekutatzen.pas iturburu-programatik abiatuta FitxategiaSortu_BiderikGabe_ExekutagarriaExekutatzen.EXE programa exekutagarria lor daiteke. Programazio-ingurunea alde batera utzita FitxategiaSortu_BiderikGabe_ExekutagarriaExekutatzen.EXE programa exekutagarria diskoaren edozein karpetara kopiatuta eta bertan exekutatuta, lortuko den Datuak.dat fitxategia programa exekutagarriaren karpeta horretan sortuko da.
    C:\KarpetaBat direktorioan gaudela .PAS iturburu-programa konpilatu
    eta .EXE programa exekutagarria lortuko da C:\KarpetaBat karpetan

    C:\BesteKarpetaBat karpetan dagoen .EXE programa
    gainean kokatu eta klik eginez hura egikaratu

    C:\BesteKarpetaBat karpetan dagoen .EXE programa egikaratzean
    Datuak-dat fitxategia sortuko da. Baina, non sortuko da?

    C:\BesteKarpetaBat karpetako .EXE programa egikaratu ondoren
    bertan sortuko da Datuak-dat fitxategia biderik ez bada zehaztu

    ADIBIDEAK

    Hona hemen fitxategien zenbait programa:

    INTEGER REAL BOOLEAN CHAR STRING ARRAY RECORD FILE