Soubory.

Proměnná typu soubor umožňuje pracovat s daty uloženými prostřednictvím operačního systému MS-DOS v souboru na disku. Soubor obsahuje libovolný počet složek libovolného typu (s výjimkou typu soubor).

Textový soubor
Typový soubor
Netypový soubor
Standartní vstupní a výstupní soubor
Parametry příkazové řádky
Přehled procedur a funkcí pro soubory


Textový soubor.

Základní položkou textového souboru je znakový typ CHAR. Do takovéhoto souboru lze zapisovat a pak z něj číst znaky, řetězce, celá a reálná čísla.

Syntaxe:

  var   t : text;     { proměnná t typu TEXTový soubor }

Základní procedury a funkce pro práci s textovým souborem:

Assign(t,název)
Přiřazení názvu souboru (řetězec - např. úplná specifikace) k proměnné souboru
Rewrite(t)
Vytvoření a otevření nového souboru pro zápis
Reset(t)
Otevření existujícího souboru pro čtení
Append(t)
Otevření textového souboru pro přidávání na konec
Close(t)
Zavření otevřeného souboru
Read(t,prom)
Čtení dat ze souboru do proměnné prom
Write(t,prom)
Zápis dat z proměnné prom do souboru
Readln(t,radek)
Čtení celého řádku z textového souboru do proměnné radek (typu string)
Writeln(t,radek)
Zápis řádku z proměnné radek do textového souboru
Eoln(t) → boolean
Testovací funkce na konec řádku textového souboru
Eof(t) → boolean
Testovací funkce na konec souboru

Pro práci se souborem existuje ukazatel aktuální pozice v souboru. Po otevření Reset nebo vytvoření Rewrite je nastaven na začátek a po otevření Append na konec souboru. Každé čtení posune tento ukazatel dál o tolik znaků, kolik se jich ze souboru čte. Procedura Readln posouvá ukazatel o celý řádek. Testovací funkce eof a eoln se nastavují po každém čtení a otevření souboru.

var
  t : text;
  ch : char;
  s10 : string[10];
  s : string;
  r : real;
begin
  assign(t,'text.txt'); {Přiřazení názvu k proměnné souboru}
  reset(t);         {Otevření souboru}
  read(t,ch);       {Přečte 1 znak a posune ukazatel o 1 znak}
  read(t,s10);      {Přečte 10 znaků a posune za ně ukazatel}
  readln(t,s10);    {Přečte 10 znaků a posune ukazatel
                     za konec řádku, zbývající znaky se přeskočí}
  readln(t,s);      {Přečte celý řádek - maximálně 255 znaků}
  read(t,r);        {Přečte reálné číslo a posune ukazatel za}
  close(t);         {toto číslo - musí být správně zapsáno !)}
end

Př.: Přečtení souboru a výpis jeho obsahu na obrazovku

program TypeText;
var
  t : text;                 {Proměnná typu textový soubor}
  s : string;               {Řádek pro čtení ze souboru}
begin
  assign(t,'text.txt');     {Přiřazení jména souboru}
  reset(t);                 {Otevření souboru pro čtení}
  while not eof(t) do       {Dokud není konec souboru}
     begin
       readln(t,s);         {Čti řádek ze souboru}
       writeln(s);          {Vypiš ho na obrazovku}
    end;
  close(t);                 {Uzavření souboru}
end.


Typový soubor.

Typ položky souboru může být libovolný jednoduchý nebo strukturovaný typ kromě typu soubor. Do takovéhoto souboru lze zapisovat a pak z něj číst pouze hodnoty takového typu, pro jaký byl soubor vytvořen.

Syntaxe:

    soubor : file of typ_položky;
 
Příklad:
    var            { proměnná typového souboru složeného ze záznamů }
      f : file of integer;
                   { proměnná typového souboru složeného
                     z celých čísel typu integer }
 
Složitější příklad:
    type           { příklad typu položky typového souboru }
      Tosoba = record
            jmeno : string[10];
            plat : real;
            pl_trida : byte;
          end;
    var            { proměnná typového souboru složeného ze záznamů }
      f : file of Tosoba;

 

Základní procedury a funkce pro práci s typovým souborem:

Assign(f,název)
Přiřazení názvu souboru k proměnné souboru
Rewrite(f)
Vytvoření a otevření nového souboru pro čtení i zápis
Reset(f)
Otevření existujícího souboru pro čtení i zápis
Close(f)
Zavření otevřeného souboru
Read(f,prom)
Čtení dat ze souboru do proměnné prom
Write(f,prom)
Zápis dat z proměnné prom do souboru
Eof(f) → boolean
Testovací funkce na konec souboru
Filepos(f) → longint
Funkce vracející aktuální pozici v souboru
Filesize(f) → longint
Funkce vracející celkový počet položek souboru
Seek(f,pozice)
Nastavení ukazatele v souboru na danou pozici v rozmezí od nuly (před první položku) do filesize(f) (za poslední položku)

Další procedury a funkce pro práci se soubory :

IOresult → byte
Test na bezchybné provedení souborové operace. Funkce vrací kód chyby nebo nulu (bez chyby) při vypnuté kontrole vstupně-výstupních chyb direktivou překladače {$I-}. a funguje jako přepínač : při výskytu chyby se žádné další operace neprovádějí, dokud nedojde k zavolání této funkce, při kterém se vynuluje číslo chyby a umožní se provádění dalších souborových operací.
Rename(f,nazev)
Přejmenování zavřeného souboru na nový !neexistující název
Erase(f)
Smazání zavřeného souboru
Truncate(f)
Zkrácení souboru po aktuální pozici - odřízne zbývající položky do konce souboru.
Filemode
Proměnná obsahující kód způsobu práce se souborem pro následující otevření :
0 - pouze pro čtení
1 - pouze pro zápis
2 - pro čtení i zápis

Př.: Přečtení celého typového souboru s položkou typu integer a výpis obsahu na obrazovku

var
  f : file of integer;     { Proměnná pro práci se souborem }
  c : integer;             { Proměnná pro čtení ze souboru }
begin
  assign(f,'cisla.dta');   { Přiřazení názvu souboru proměnné f }
  reset(f);                { Otevření souboru }
  while not eof(f) do      { Dokud není konec souboru dělej }
    begin
      read(f,c);           { Čti položku ze souboru }
      writeln(c:10);       { Vypiš data na obrazovku }
    end;
  close(f);                { Uzavření souboru }
end.

Př.: Přečtení celého typového souboru s položkou typu integer a výpis obsahu na obrazovku - jiný způsob

var
  f : file of integer;     { Proměnná pro práci se souborem }
  c : integer;             { Proměnná pro čtení ze souboru }
  i : integer;             { Řídící proměnná cyklu }
begin
  assign(f,'cisla.dta');   { Přiřazení názvu souboru proměnné f }
  reset(f);                { Otevření souboru }
  for i:=1 to filesize(f) do
                           { Pro všechny položky souboru dělej }
    begin
      read(f,c);           { Čti položku ze souboru }
      writeln(c:10);       { Vypiš data na obrazovku }
    end;
  close(f);                { Uzavření souboru }
end.

Př.: Přečtení celého typového souboru s položkou typu záznam a výpis obsahu na obrazovku, včetně ošetření chyby neexistujícího souboru.

type
  Tzaznam = record          { Typ položky souboru }
        nazev : string[10];
        cena : real;
            end;
var
  f : file of Tzaznam;      { Proměnná pro práci se souborem }
  zaz : Tzaznam;            { Proměnná pro čtení ze souboru }
begin
  assign(f,'data.dta');     { Přiřazení názvu souboru proměnné f }
  {$I-}                     { Vypnutí kontroly IO operací }
   reset(f);                { Otevření existujícího souboru }
  {$I+}                     { Zapnutí kontroly IO operací }
  if IOresult = 0           { Zjištění stavu po otevření souboru }
    then                    { Když se soubor podařilo otevřít, můžeme číst }
      begin
        while not eof(f) do { Dokud není konec souboru dělej }
          begin
            read(f,zaz);    { Čti položku ze souboru }
            with zaz do
              writeln(nazev,cena:10:2); { Vypiš data na obrazovku }
          end;
        close(f);           { Uzavření souboru }
      end
    else writeln('Soubor neexistuje.'); { Chyba při otvírání souboru }
end.


Standartní vstupní a výstupní soubor.

Standartní vstupní a výstupní soubory jsou použity jako implicitní při všech vstupně-výstupních operacích (příkazy read a write). Oba soubory jsou typu text. (příkaz read(cislo); je totéž jako read(input,cislo);) Standartní vstupní soubor INPUT klávesnice Standartní výstupní soubor OUTPUT obrazovka

Pro univerzální výstup na obrazovku nebo do souboru na disku lze proměnné textového souboru t přiřadit standartní výstupní soubor (obrazovku) procedurou AssignCRT(t) Pro výstup na tiskárnu lze otevřít textový soubor PRN.

Př.: Univerzální výpis.

Program Universal;
uses CRT;

function Vystup(var f : text; co : string) : boolean;
begin
  {$I-}  writeln(f,co);  {$I+}
        {Pokus o výpis při vypnuté kontrole IO operací}
  Vystup:=IOresult=0;
        {Testování výsledku operace - výstup bude false
         když IOresult nevrátí nulu}
end;

var f : text;
begin
  AssignCRT(f);
        {Přiřazení standartního výstupního souboru
         (obrazovky) proměnné f}
  Rewrite(f);
  if Vystup(f,'Toto je na obrazovku')
    then writeln('Vypsáno na obrazovku')
    else writeln('Chyba při výpisu na obrazovku');
  Assign(f,'PRN');
        {Přiřazení tiskárny operačního systému proměnné f}
  Rewrite(f);
  if Vystup(f,'Toto je na tiskárnu')
    then writeln('Vypsáno na tiskárnu')
    else writeln('Chyba při výpisu na tiskárnu');
end.


Parametry příkazové řádky.

Pro zpracování parametrů předávaných programu při spuštění z příkazové řádky MS-DOSu slouží dvě funkce :
Paramcount → word
vrací počet parametrů, které byly programu předány při spuštění.
Paramstr(n) → string
vrací n-tý parametr z příkazové řádky, kde n je v rozsahu 0 až Paramcount, přičemž nultým "parametrem" je úplná specifikace spuštěného programu

Pozn.: V integrovaném prostředí Turbo Pascalu lze při ladění programu napsat parametry příkazové řádky v menu F10 - Run - Parameters

Př.:

program Parametry;
var
  i : integer;
begin
  writeln('Program ',paramstr(0),' obdržel parametry v počtu : ',paramcount);
  for i := 1 to paramcount do
    writeln('Parametr (',i,') : ',paramstr(i));
end.


Netypový soubor.

Netypový soubor se používá pro ukládání a čtení bloků dat. Je určen pro rychlou práci se souborem, protože čtení a zápis probíhá po blocích pomocí DMA (Direct Memory Acces - přímý přístup do paměti), kdy data z disku jdou zvláštním DMA kanálem přímo do paměti RAM a ne přes registry procesoru => rychlejší zpracování. Data pro přenos mohou být v proměnné libovolného typu (kromě typu soubor).

Velikost jedné položky souboru lze libovolně určit při vytváření nebo otvírání v rozsahu 1 - 65535 bajtů, implicitní velikost je 128 bajtů. Určuje se podle velikosti bufferu.

Syntaxe:

    var f : file;     { proměnná f netypového souboru }

Speciální procedury pro práci s netypovým souborem :

Rewrite(f[,velikost])
Vytvoření a otevření nového souboru pro čtení i zápis a určení velikosti položky
Reset(f[,velikost])
Otevření existujícího souboru pro čtení i zápis a určení velikosti položky
Blockread(f,Buff,Count[,Result])
Načtení bloku dat ze souboru do paměti
Blockwrite(f,Buff,Count[,Result])
Zápis bloku dat z paměti do souboru
Buff - identifikátor proměnné libovolného typu pro data
Count - požadovaný počet položek pro přenos
Result - nepovinný parametr - počet skutečně přenesených položek

Př.: Přečtení obsahu typového souboru s položkou typu integer prostřednictvím netypového souboru.

program ReadFile;
var
  f: file;
  NumRead, i : Word;
const
  SizeBuf=1024;
var
  Buf: array[1..SizeBuf] of integer;
begin
  Assign(f,'cisla.dta');       {Jméno vstupního souboru}
  Reset(f, sizeof(integer));   {Velikost záznamu = velikost typu Integer v bajtech}
  repeat                       {Načtení dat ze souboru, jestli je v něm
                                   více položek než SizeBuf, budeme opakovat}
    BlockRead(f, Buf, SizeBuf, NumRead);
                               {Požadujeme SizeBuf položek,
                                skutečný počet položek bude v NumRead}
    for i:=1 to NumRead do     {Výpis všech právě načtených čísel}
      writeln(Buf[i]:10);
  until (NumRead <SizeBuf);    {Načetlo se méně než se požadovalo = konec čtení}
  Close(f);
end.

Př.: Kopírování souboru pomocí DMA.

program CopyFile;
var
  FromF, ToF: file;
  NumRead, NumWritten: Word;
  Buf: array[1..2048] of byte;
begin
   Assign(FromF, ParamStr(1));  {Jméno vstupního souboru}
   Reset(FromF, 1);             {Velikost záznamu = 1}
   Assign(ToF, ParamStr(2));    {Jméno výstupního souboru}
   Rewrite(ToF, 1);             {Velikost záznamu = 1}

  writeln('Kopíruje se...');
  repeat
    BlockRead(FromF, Buf, SizeOf(Buf), NumRead);
    BlockWrite(ToF, Buf, NumRead, NumWritten);
  until (NumRead <SizeOf(Buf))     {Konec souboru}
        or (NumWritten <> NumRead);{Chyba při zápisu}
  if NumWritten = NumRead
    then writeln('Kopírování skončeno.')
    else  writeln('Chyba při zápisu do souboru.');
  Close(FromF);
  Close(ToF);
end.


Přehled procedur a funkcí pro soubory.

NázevFunkceSoubor
Textový Typový Netypový
assignPřiřazení názvu souboru souborové proměnnéano ano ano
assignCRTPřiřazení obrazovky souborové proměnnéanonene
rewriteVytvoření a otevření nového souboru W RW RW
resetOtevření existujícího souboru R RW RW
appendOtevření textového souboru pro přidávání na konec Wnene
filemodeZpůsob otevření souboru (0=R, 1=W, 2=RW)ne ano ano
closeZavření otevřeného souboruano ano ano
readČtení dat ze souboru do proměnné ano anone
writeZápis dat z proměnné do souboru ano anone
readlnČtení celého řádku z textového souboruanonene
writelnZápis řádku do textového souboru anonene
blockreadNačtení bloku dat ze souboru do paměti nene ano
blockwriteZápis bloku dat z paměti do souboru nene ano
IOresultTest na bezchybné provedení souborové operace ano ano ano
eolnTestovací funkce na konec řádku textového souboru anonene
eofTestovací funkce na konec souboru ano ano ano
fileposFunkce vracející aktuální pozici v souboru ne ano ano
filesizeFunkce vracející celkový počet položek souboru ne ano ano
seekNastavení ukazatele v souboru na danou pozicine ano ano
truncateZkrácení souboru po aktuální pozici ne ano ano
renamePřejmenování zavřeného souboruano ano ano
eraseZrušení zavřeného souboru ano ano ano
settextbufNastavení vyrovnávací paměti pro textové soubory anonene
flushVyprázdnění vyrovnávací paměti při zápisu anonene
seekeolnTest, zda na řádku jsou ještě nějaká data anonene
seekeofTest, zda v souboru jsou ještě nějaká dataanonene

Př.: Funkce testující existenci souboru.

program JeSoubor;

function Exist(name : string) : boolean;
var f : file;
begin
  assign(f,name);               {Přiřazení jména souboru}
  {$I-} reset(f); {$I+}         {Pokus o otevření}
   if IOresult=0                {Bez chyby, soubor existuje}
     then begin close(f); exist:=true; end
     else Exist:=false;         {Soubor neexistuje}
end;

const InitName='program.ini';
var f : text;

begin
  assign(f,InitName);           {Přiřazení jména souboru}
  if Exist(InitName)            {Existuje-li soubor}
    then append(f)              {přidáme na konec}
    else rewrite(f);            {jinak vytvoříme nový}
  ..................................
  writeln(f,'Dalsi data ');     {Zápis na konec souboru}
  close(f);                     {Uzavření souboru}
end.