Pascal programozás alap és haladó szinten!
Mindenkinek akit kicsit is érdekel ,de tudni akar! AZ övék ez a honlap!
Weboldal bejelentése
Szabálysértő honlap?
Kérünk, jelentsd be!
Ügyfélszolgálat
Állománykezelés
A programok a bemeneti adataikat nem csak a billentyûzetrõl, hanem a háttértárolókon lévõ állományokból is kaphatják, valamint kimeneti adataikat a képernyõn történõ megjelenítés mellett állományokban is tárolhatják. A Pascal nyelvben három összetett típus és az ezekhez kapcsolódó szabványos eljárások és függvények valósítják meg az állományok kezelését.
8.1 Típusos állomány
Deklarálása: FILE OF alaptípus
Összetett típus, fizikailag egy lemezes állomány. Egyforma méretû elemekbõl (komponensekbõl) áll. Az elemek számának csak a lemez mérete szab határt.
A típusos állományból való olvasás illetve az állományba való írás egysége a komponens. Az elemekhez a rendszer sorszámot rendel 0-tól kezdõdõen. Az elérés szekvenciálisa (Read, Write) vagy a komponensek sorszáma szerint direkt módon történhet (az állomány mutató mozgatásával).
A program mindig egy logikai állományt kezel, melyet hozzá kell rendelnünk egy fizikai állományhoz (Assign), majd használat elõtt meg kell nyitnunk. A Rewrite eljárás létrehozza, és megnyitja a logikai fájlhoz rendelt fizikai állomány. Ha a fizikai fájl már létezett, akkor törli annak tartalmát. A Reset eljárással egy már létezõ állományt nyithatunk meg. Ekkor az állománymutató az 0. komponensre áll. (Ezért ezt az eljárást használhatjuk egy nyitott állomány elejére való ugrásra is.) Használat után a Close eljárással zárjuk le fájlunkat!
A típusos állományból a Read eljárás olvas be változókba adatokat. Ügyeljünk arra, hogy a változó típusa egyezzen meg a fájl alaptípusával! Beolvasás után az állomány mutató automatikusan a következõ komponensre lép (szekvenciális elérés). Egy változó (vagy kifejezés) értékét a Write eljárással írhatjuk ki egy fájlba. Hasonlóan az olvasáshoz a változó típusának meg kell egyeznie a fájl elemeinek a típusával, valamint az eljárás után az állomány mutató továbblép. Ha az állomány mutató a fájl végén (az utolsó elem mögött) áll, akkor az Eof függvény értéke True. Nézzünk egy példát a fájl szekvenciális feldolgozására:
Reset(f)
while not Eof(f) do
begin
Read(f,v);
{a v változóban lévõ adat feldolgozása}
end;
Az állomány mutató direkt pozicionálását a Seek eljárás valósítja meg. A FilePos függvénnyel lekérdezhetjük az aktuális pozíciót, a FileSize függvény pedig az állomány elemeinek a számát (méretét) adja vissza. Példák a pozicionálásra.: Pozicionálás a típusos állományban – példák
1. A fájl egy elemének módosítása
...
Read(f, v);
v := ... {az elem módosítása}
Seek(f, FilePos(f) - 1); {visszalépés az elem helyére a fájlban}
Write(f, v);
...
2. Pozicionálás az állomány végére (az utolsó elem után)
Seek(f, FileSize(f));
3. Pozicionálás az utolsó elemre
Seek(f, FileSize(f) - 1);
4. Pozicionálás az elsõ elemre
Seek(f, 0);
Az I/O mûveletek során nagy a hibalehetõség (pl. a lemezegység, fájl nem elérhetõ). Az esetleges futási hibákat tudnunk kell kezelni, ha megbízhatóan mûködõ programot szeretnénk írni. Ha az I/O mûveletek ellenõrzése aktív (ez az alapértelmezés), akkor programunk futási hibával leáll egy I/O hiba esetén. Ezért I/O mûveletek ellenõrzését inaktívvá kell tennünk a {$I-} fordítási direktívával a kényes mûveletek esetén. A mûvelet után az esetleges hiba kódját az IOResult függvénnyel kérdezhetjük le. Erre egy példa:
Assign(f, 'adatok.dat');
{$I-}
Reset(f); {megpróbáljuk megnyitni a fájlt}
{$I+}
if IOResult <> 0 then {ha hiba történt, tehát a fájl nem létezik, }
Rewrite(f); {akkor létrehozzuk az állományt}
A Truncate eljárással levághatjuk a fájl komponenseit az aktuális pozíciótól kezdõdõen.
Lezárt állományokra használhatjuk a Rename valamint az Erase eljárásokat a fájlok átnevezésére illetve törlésére.
Példa: 1. A program egy bolt árucikkeinek adatait (név, kód, ár) tárolja és kezeli egy állományban. Megoldás: Típusos állomány - példaprogram
program aruk;
uses crt;
type TAru = record {A fájl alaptípusa.}
kod: string;
nev: string[15];
ar: real;
t: boolean; {Ez a mezõ jelzi, hogy e rekord törölt-e (logikai törlés).}
end;
var bolt: file of TAru;
aru: TAru;
mkod: string;
mvalasz: char;
{Megkeres egy adott kódú rekordot az állományban.}
function Van(kodja: string): boolean;
var talalt: boolean;
begin
seek(bolt,0);
talalt := false;
while not Eof(bolt) and not talalt do
begin
read(bolt, aru);
if (aru.kod = mkod) and not aru.t then
talalt := true;
end;
van := talalt;
end;
{Egy rekord felvitele az állományba.}
procedure Bevitel;
begin
ClrScr;
WriteLn('Kerem a kodot!'); ReadLn(mkod);
if not Van(mkod) then
begin
Seek(bolt, filesize(bolt)); {Pozicionálás a fájl végére.}
WriteLn('Kerem az aru nevet!');
ReadLn(aru.nev);
WriteLn('Kerem az aru arat!');
ReadLn(aru.ar);
aru.t := false;
aru.kod := mkod;
Write(bolt, aru);
end
else
begin
WriteLn('Mar van ilyen kod!');
ReadKey
end
end;
{Egy rekord módosítása a fájlban.}
procedure Modosit;
begin
ClrScr;
WriteLn('Kerem az aru kodjat!');
ReadLn(mkod);
if Van(mkod) then
begin
Seek(bolt, FilePos(bolt) - 1);
WriteLn('Kerem az aru nevet!');
ReadLn(aru.nev);
WriteLn('Kerem az aru arat!');
ReadLn(aru.ar);
aru.t := false;
aru.kod := mkod;
Write(bolt, aru);
end
else
begin
Writeln('Nincs ilyen aru!');
ReadKey
end;
end;
{Egy rekord logikai törlése: a t mezõt True értékûre állítja,
az ilyen rekordokat a program nem létezõnek tekinti.
Fizikai törlés kilépéskor.}
procedure Torles;
begin
ClrScr;
WriteLn('Kerem az aru kodjat!');
ReadLn(mkod);
if Van(mkod) then
begin
Seek(bolt, FilePos(bolt) - 1);
aru.t := true;
Write(bolt, aru);
end
else
begin
WriteLn('Nincs ilyen aru!');
ReadKey
end
end;
{A fájl tartalmának kiírása a képernyõre.}
procedure Lista;
begin
ClrScr;
Seek(bolt, 0);
while not Eof(bolt) do
begin
Read(bolt, aru);
if aru.t = false then
begin
Write(aru.kod);
GotoXy(30, wherey); write(aru.nev);
GotoXy(60, wherey); writeln(aru.ar:10:0);
end;
end;
ReadKey
end;
{Fizikai törlés: azon rekordok átmásolása egy új állományba, melyek nincsenek logikailag törölve.
A régi állomány törlése, az új fájl átnevezése a régi nevére.}
procedure Surites;
var ujfile: file of TAru;
begin
Assign(ujfile, 'ujfile');
Rewrite(ujfile);
Seek(bolt, 0);
while not Eof(bolt) do
begin
Read(bolt, aru);
if aru.t = false then write(ujfile, aru);
end;
Close(bolt);
Erase(bolt);
Close(ujfile);
Rename(ujfile, 'bolt');
end;
{Fõprogram, menü.}
begin
clrscr;
Assign(bolt, 'bolt');
{$I-}
Reset(bolt);
{$I+}
if IOResult <> 0 then Rewrite(bolt);
repeat
ClrScr;
WriteLn('1. Adatbevitel');
WriteLn('2. Modositas');
WriteLn('3. Torles');
WriteLn('4. Listazas');
WriteLn('5. Vege');
WriteLn('Valassz!');
repeat mvalasz := readkey until mvalasz in['1'..'5'];
case mvalasz of
'1': bevitel;
'2': modosit;
'3': torles;
'4': lista;
'5': surites;
end;
until mvalasz = '5';
end.
8.2 Szöveges állomány - Text
Deklarálása: TEXT
A Pascal programban szöveges állományként kezelhetjük az egyszerû ASCII szövegeket. A szöveges állomány változó hosszúságú sorokból áll, melyeket a sorvégjel zár le (CR/LF). Az állományt az állományvégjel zárja(^Z). Az Eoln illetve az Eof függvény értéke True, ha az aktuális pozíció egy sorvégjelen vagy az állomány végén áll. A SeekEoln illetve a SeekEof függvények az állomány következõ TAB szóköz illetve TAB szóköz és sorvégjel karaktereit átugorva tájékoztatnak arról, hogy sorvégjelen illetve az állomány végén állunk-e.
A szöveges állományt csak szekvenciálisan érhetjük el. Az állomány csak olvasásra vagy csak írásra lehet megnyitni. Az állományból olvasni a Read, ReadLn, illetve írni a Write, Writeln eljárásokkal tudunk. Ha az eljárásoknak a fájl azonosító paraméterét elhagyjuk, akkor az olvasás / írás az alapértelmezett input / output szöveges állományból / -ba történik, ami a billentyûzet illetve a monitor. Szöveges állományból (azaz a billentyûzetrõl is) olvashatunk egész, valós, karakteres és sztring típusú változokba adatokat. Az állományba az elõbbi típusokon kívül még logikai értéket is kiírathatunk. Az fizikai állományhoz az Assign eljárással rendelhetünk egy Text típusú változót, azaz a logikai állományt. A Rewrite eljárás csak írásra nyitja meg a szöveges állományt, ha nem létezett létrehozza, egyébként törli a tartalmát. A Reset eljárással csak olvasásra nyithatunk meg egy már létezõ fájlt. Az Append eljárás egy létezõ állományt nyit meg írásra, és az állománymutató a fájl végére állítja. Az állományt a Close eljárással zárhatjuk be. Az I/O mûveletek hibakódját az IOResult függvény adja vissza (bõvebben ld. Típusos állományok). Lezárt állományokra használhatjuk a Rename valamint az Erase eljárásokat a fájlok átnevezésére illetve törlésére. A Fluss és a SetTextBuf eljárásokkal az írás, olvasás során a rendszer által használt átmeneti tárolóhoz (pufferhez) férhetünk hozzá.
Példa: 1. A doga.txt állományban egy feladatsor van, kérdések és válaszok felváltva egymás után. Minden kérdés illetve válasz új sorban kezdõdik. A kérdések egy számjeggyel kezdõdnek, és kérdõjellel fejezõdnek be. Készítsünk két új szöveges állományt úgy, hogy az egyik csak a kérdéseket, a másik pedig csak a válaszokat tartalmazza. Megoldás: Szöveges állomány - példaprogram
program Doga;
var f, k, v: text;
s: string;
kerd: boolean;
begin
Assign(f, 'doga.txt');
Assign(k, 'kerd.txt');
Assign(v, 'val.txt');
Reset(f);
Rewrite(k);
Rewrite(v);
while not Eof(f) do
begin
ReadLn(f, s); {Egy sor beolvasása a dolgozatból}
if s[1] in ['1'..'9'] then kerd := true; {A sor elsõ karaktere számjegy-e (kérdés)}
if kerd then WriteLn(k, s) else WriteLn(v, s); {Kiírás a megfelelõ állományba}
if s[Length(s)] = '?' then kerd := false; {Vége-e a kérdésnek}
end;
Close(f);
Close(k);
Close(v)
end.
8.3 Típusnélküli állomány
Deklarálása: FILE
Általában gyors adatmozgatás vagy ismeretlen állomány esetén használjuk. Hasonló a típusos állományhoz, de az elemeinek nem a típusa, hanem a hossza a lényeges. A komponensek hosszát a fájl megnyitásakor adhatjuk meg (Reset, Rewrite), az alapértelmezés 128 bájt. Az állomány írható, olvasható, az elérés szekvenciálisan (BlockRead, BlockWrite eljárásokkal) vagy az elemek sorszáma szerint direkt módon történhet.
További függvények, eljárások: Assign, Close, Eof, Erase, FilePos, FileSize, IOResult, Rename, Seek, Truncate
Példa:
1. Tördeljünk szét egy állományt egy kilobájt hosszúságú kisebb állományokra!
Megoldás :
Típusnélküli állomány - példaprogram
program Tordel;
uses Crt;
var forras, cel: file;
n, maradek: integer;
s: string;
t: array[1..1024]of byte;
begin
Assign(forras, 'nagyfajl.arj');
Reset(forras,1); {Megnyitás egy bájt elemhosszúsággal}
n := 0;
while not Eof(forras) do
begin
inc(n);
str(n,s);
Assign(cel, 'kisfajl.'+s); {A cél állomány hozzárendelése, a kiterjesztés a sorszám}
Rewrite(cel,1);
maradek := FileSize(forras)-FilePos(forras); {A forrás még át nem másolt részének a hossza}
if maradek >= 1024 then
begin
BlockRead(forras, t, 1024);
BlockWrite(cel, t, 1024);
end
else
begin
BlockRead(forras, t, maradek);
BlockWrite(cel, t, maradek);
end;
Close(cel)
end;
Close(forras)
end.
Honlapkészítés ingyen:
Ez a weblapszerkesztő alkalmas
ingyen weboldal,
ingyen honlap készítés...
Mai: 4
Tegnapi: 26
Heti: 41
Havi: 106
Össz.: 153 457
Látogatottság növelés
Pascal programozás alap és haladó szinten! - © 2008 - 2024 - kerigseoszt.hupont.hu