Dátový typ súbor a práca so súbormi.

Príkazy vstupu a výstupu.

Ladiace údaje v súboroch.

---

---

Textové súbory TEXT

Súbor = postupnosť (sekvencia) prvkov rovnakého typu, zvyčajne uložená na vonkajšom pamäťovom médiu.

Príklad: Program nájde maximálne číslo v súbore celých čísel:

var
 t:Text;
 cislo,max:integer;
begin
 Assign(t,'text.txt'); Reset(t);
 max:=-maxint; 
 while not Eof(t) do begin 
 read(t,cislo);
 if cislo>max then max:=cislo;
 end;
 Close(t);
 if max=-maxint then
 writeln('súbor je prázdny')
 else
 writeln('maximálne číslo v súbore je ',max);
end;

· ak súbor obsahoval napr. len prázdny riadok (alebo len medzery), tak program vypíše, že maximum bolo 0

· toto isté sa stane, ak súbor obsahuje len záporné čísla a za posledným číslom sú ešte nejaké medzerové znaky - funkcia Eof(t) za posledným číslom vráti false - ešte nie je koniec súboru, ale už tam nie je žiadne číslo, teda načíta sa hodnota 0

Zápis čísel

· pomocou write(t, ...) môžeme do textového súboru zapisovať aj čísla (hodnoty číselných výrazov)

· celé čísla sa zapíšu bez medzery pred číslom aj za číslom, t.j. write(t,i,i+1) pre i=17 zapíše 1718

· reálne čísla sa do súboru zapisujú v semilogaritmickom tvare s medzerou pred číslom

Príklad: Zo súboru text1.txt budeme kopírovať všetky čísla do súboru text2.txt, pričom ich budeme zaraďovať po troch do riadka:

var
 t1,t2:Text;
 cislo,pocet:integer;
begin
 Assign(t1,'text1.txt'); Reset(t1);
 Assign(t2,'text2.txt'); Rewrite(t2);
 pocet:=0;
 while not Eof(t1) do begin
 read(t1,cislo); write(t2, cislo); inc(pocet); 
 if pocet=3 then begin
 writeln(t2); pocet:=1;
 end
 else begin
 if pocet>0 then write(t2,' ');
 inc(pocet);
 end;
 end;
 Close(t1);
 Close(t2);
end;

Príklad: V súbore sú reálne čísla, máme zistiť počet čísel, ktoré majú hodnotu menšiu ako je priemer všetkých čísel v súbore

var
 t:Text;
 cislo,suma,priemer:real;
 pocet:integer;
begin
 Assign(t,'text1.txt'); Reset(t);
 { priradenie vstupného súboru a jeho otvorenie na čítanie}
 suma:=0; pocet:=0;
 while not Eof(t) do begin
 read(t,cislo);
 suma:=suma+cislo; inc(pocet);
 end;
 Reset(t);  { !!! nové nastavenie pozície na začiatok súboru !!!}
 priemer:=suma/pocet; pocet:=0;
 { pocet už nepotrebujeme}
 while not Eof(t) do begin
 read(t,cislo);
 if cislo<priemer then inc(pocet);
 end;
 writeln('počet podpriemerných=',pocet);
end;

Formátovací parameter vo write

· za znakom alebo znakovým reťazcom
   write(t,'*':10);
označuje, že znak sa vypíše na šírku 10, t.j. najprv 9 medzier a potom '*'
   write(t,'delphi':3);
nakoľko reťazec je dlhší ako formátovací parameter, zapíše sa kompletný reťazec, t.j. ignoruje sa formát

· formátovací parameter za celým číslom označuje šírku, do ktorej sa má zapísať číslo, ak by nevošlo do danej šírky, formát sa ignoruje
    write(t,25*25:5);
zapíše dve medzery, za ktoré dá číslo 625

· formátovací parameter za reálnym číslom tiež označuje šírku, číslo sa vypíše v semilogaritmickom tvare; druhý formátovací parameter označuje počet desatinných miest
    write(t,sin(2):15);
zapíše  9.092974E-0001
    write(t,cos(2):7:4);
zapíše -0.4161

 Znakové reťazce

· údajový typ, ktorý obsahuje postupnosť znakov (char)

o porovnajte s Text

· znaky v postupnosti sú očíslované od 1 až po momentálnu dĺžku reťazca

· funkcia Length vráti momentálnu dĺžku

· deklarujeme:
  var s:string;

· premenná  s môže mať zatiaľ nedefinovanú hodnotu - musíme niečo priradiť - reťazcovú konštantu:
  s:='reťazec';

· premenná s obsahuje postupnosť znakov dĺžky 7: prvý znak je 'r', druhý 'e', atď.

· Length(s) je teraz 7

· reťazcové konštanty sú uzavreté rovnako ako znakové konštanty v apostrofoch

· prázdny reťazec:
  s:='';

· premenná s obsahuje prázdnu postupnosť znakov - dĺžka je 0

· môžeme pracovať s jednotlivými prvkami postupnosti, t.j. so jednotlivými znakmi v reťazci:
  s:='abcdef';
  s[3]:='*';

· najprv sme do s priradili 5-znakový reťazec a potom sme v ňom zamenili 3-tí znak (znak 'c') za hviezdičku

· nesmieme sa odvolávať na znaky mimo rozsahu 1 a momentálna dĺžka, napr.
  s[10]:='+';   // reťazec má zatiaľ dĺžku len 6

· spôsobí chybovú hlášku

· okrem priradení môžeme reťazce zapisovať do textového súboru a tiež ich môžeme zo súboru čítať:

· write(t, premenná_typu_string );   // výpis hodnoty premennej

· read(t, premenná_typu_string );   // načítanie riadku zo vstupu

· operácie so znakovými reťazcami:

· logické operátory: =, <>, <, >, <=, >=

· napr. 'abc'>'ABC', 'jana'<'jano'    - hovoríme tomu lexikografické usporiadanie

§ postupne sa porovnáva znak za znakom, kým sú rovnaké v oboch reťazcoch, tak sa pokračuje v porovnávaní, keď sa narazí na rozdielne znaky, tak tieto sa porovnajú a nastavia výsledok porovnania

§ porovnávanie samotných znakov sa robí podľa pravidiel char: t.j. menší je znak s menším ascii-kódom

· zreťazenie reťazcov '+' (+ je polymorfný operátor - závisí od typu operandov), napr.
  s:='abc'+'def';   // s='abcdef'
  s:=''; for i:=1 to 10 do s:=s+'*';    // s='**********'

Krátke znakové reťazce

• v Turbo pascale je typ string, pri ktorom sme do hranatých zátvoriek zapisovali nejaké číslo od 1 do 255 - maximálnu dĺžku reťazca, napr.
    var s:string[20];
• označuje, že premenná s bude môže mať maximálnu dĺžku 20 znakov - priradenie dlhšieho reťazca spôsobí odhodenie všetkých znakov za 20. znakom
• aj v Objektovom pascale fungujú takéto reťazce - my ich budeme používať veľmi zriedka
• zápis
    var s:string;
• označoval reťazec maximálnej dĺžky 255 znakov - toto je zrejme už v Objektovom pascale inak
• pri priraďovaní :=, ak je ľavá strana kratšia ako pravá, tak sa reťazec oreže
• napr. s:='abcd'+'efgh'+'ijkl'; pre s:string[10]) je výsledné s='abcdefghij'
• tento typ reťazcov budeme používať veľmi zriedka - len v špeciálnych prípadoch

Preddefinované (štandardné) podprogramy s reťazcami

• Length( reťazec )
• táto funkcia vráti momentálnu dĺžku reťazca
• SetLength( reťazcová_premenná , dĺžka )
• táto procedúra nastaví dĺžku reťazca
• pre krátke reťazce nesmie presiahnuť deklarované maximum
• ak je menšia ako momentálna dĺžka, znaky na konci sa strácajú
• ak je väčšia ako momentálna, tak pridané znaky (od konca) majú nedefinovanú hodnotu
• Copy( reťazec , od , koľko )
• táto funkcia vráti nový reťazec - podreťazec pôvodného
• ak je od mimo rozsahu, vráti prázdny reťazec, t.j. '', napr.
    s:=copy('abcde',2,3) => s='bcd'
    s:=copy('abcde',7,3) => s=''
    s:=copy('abcde',3,5) => s='cde'
• ak potrebujeme podreťazec od nejakého indexu až do konca, nemusíme vypočítať presný počet, ale môžeme použiť konštantu maxInt, napr.
    s:=copy('abcde',3,maxInt)
• Pos( podreťazec , reťazec )
• táto funkcia vráti začiatočný index prvého výskytu podreťazca v reťazci alebo 0, ak sa v reťazci podreťazec nenachádza, napr.
    i:=pos('d','abcde');     => i=4
    i:=pos('x','abcde');     => i=0
    i:=pos('ba','abababab'); => i=2

Podprogramy na reťazcoch

program zistí počet všetkých výskytov podreťazca v reťazci:

var
 s,p:string;
 i,j,poc:integer;
begin
 ...
 poc:=0; j:=0;
 repeat
 i:=pos(p,copy(s,j+1,MaxInt));
 if i>0 then begin inc(poc); j:=j+i end;
 until i=0;
 ...
end;

príklad: všetky výskyty znaku ' ' nahraď '***':

repeat
 i:=pos(' ',s);
 if i>0 then s:=copy(s,1,i-1)+'***'+copy(s,i+1,MaxInt);
until i=0;

Ďalšie preddefinované (štandardné) procedúry/funkcie s reťazcami:

• ukážeme, ako by sme mohli sami naprogramovať napr. funkciu pos

ukážka funkcie pos:

function pos(const p,s:string):integer;
var
 nasiel:boolean;
begin
 nasiel:=false; Result:=0;
 while (Result<length(s)) and not nasiel do begin
 inc(Result);
 nasiel:=p=copy(s,Result,length(p));
 end;
 if not nasiel then Result:=0;
end;

Funkcia delete(s,od,kolko)

• zmení reťazec s, tak, že vypustí kolko znakov z pôvodného s od pozície od:

ukážka funkcie delete:

procedure delete(var s:string; od,kolko:integer);
begin
 s:=copy(s,1,od-1)+copy(s,od+kolko,MaxInt);
end;

Procedúra insert(co,s,od);

• vloží podreťazec co do reťazca s od zadanej pozície od:

ukážka procedúry insert:

procedure insert(const co:string; var s:string; od:integer);
begin
 s:=copy(s,1,od-1)+co+copy(s,od,MaxInt);
end;

Procedúra str(číslo,s);

• prevod čísla na reťazec
• napr.
    str(123,s); -> s='123'
    str(-5.72,s); -> s='-5.72';
    str(123:5,s); -> s=' 123'
    str(-5.72:7:3,s); -> s=' -5.720';

naša zjednodušená verzia:

procedure str(c:integer; var s:string);
var
 znam:boolean;
begin
 znam:=c<0; if znam then c:=-c;
 s:='';
 repeat
 s:=chr(c mod 10+ord('0'))+s;
 c:=c div 10;
 until c=0;
 if znam then s:='-'+s;
end;