Operacje na plikach

CodeLan

Pliki przechowywane na dysku twardym mogą być formatu tekstowego lub binarnego. Gdy otworzysz plik tekstowy, można

przeczytać konkretną wiadomość, ale gdy otworzysz w edytorze tekstu plik binarny zobaczysz wiele nic nie mówiących znaków.

Dla komputera mają one jednak znaczenie.

W plikach przechowujemy dane, które chcemy zatrzymać po wyłączeniu programu. Mogą w nich też znajdować się potrzebne

informacje do działania naszego programu. Np. mapy do gry, zdjęcia, muzyka, lista najlepszych wyników.

Obsługa plików tekstowych
Obsługa plików typu tekstowego jest bardzo prosta. Prawie nie różni się od zwyczajnego używania procedur Write, WriteLn,

Read, ReadLn. Najpierw jednak potrzebujemy otworzyć konkretny plik i zapamiętać jego uchwyt (miejsce przez które będziemy się

z nim łączyli). Potem używamy odpowiednich procedur (Read, Write). Na koniec zamykamy plik. I to wszystko!

Otwieranie plików
Kojarzenie plików odbywa się przed ich otwarciem, za pomocą procedury Assign(var F:File; FileName:string); Dzięki

kojarzeniu przypisujemy pewnej zmiennej uchwyt, czyli miejsce w pamięci, które będzie identyfikować nasz plik.

Otwieranie do odczytu
Aby otworzyć plik do odczytu skorzystaj z procedury Reset(var F:FILE; [RecSize:Word]). Zmienna pierwsza typu FILE jest

właśnie uchwytem do pliku, druga oznacza rozmiar odczytywanego rekordu, domyślnie 128.

Otwieranie do zapisu
Do tego celu służy procedura Rewrite(var F:FILE; [RecSize:Word]). Jej parametry skonstruowane podobnie jak Reset.

Przykłady użycia

{naglowek i potrzebne zmienne}
program zapis_i_odczyt;
var F:Text;
s:string;
begin
{najpierw zapis do pliku}
Assign(F, 'plik.txt');
Rewrite(F);
WriteLn(F, 'Ala ma kota');
Close(F);

{teraz odczyt z pliku}
Assign(F, 'plik.txt');
Reset(F);
ReadLn(F, s);
Close(F);

WriteLn(s);
end.

Z plików tekstowych można odczytywać również liczby. Jeśli ma być ich wiele, muszą być oddzielone pojedynczymi spacjami.

Wtedy podobnie jak wczytujemy z klawiatury, możemy użyć wczytywania z plików,

np. odczytanie trzech liczb z pliku, którego zawartość to:
1 2 3

wykonujemy za pomocą

ReadLn(F, a, b, c);

Gdy w następnej lini jest kilka innych liczb można wczytać je w kolejnej instrukcji ReadLn.

Uwaga!
Nie polecam traktowania pliku binarnego (np. bitmapy) jako tekstowy i odczytywania jego zawartości po jednym znaku typu char (ani kopiowania plików w ten sposób). Oczywiście całość zadziała i można wyświetlić taki rysunek lub skopiować plik, jednak wczytywanie z pliku bajt po bajcie (również zapisywanie) jest bardzo czasochłonne. Zwykła bitmapa może być wczytywana nawet
kilka sekund! Za pomocą instrukcji BlockRead i BlockWrite można to zrobić w granicach kilkunastu milisekund.

Pliki binarne

Wczytywanie i zapisywanie w plikach binarnych odbywa się za pomocą instrukcji BlockRead, BlockWrite; Najlepiej zobaczyć

prosty przykład w pomocy pascala, który kopiuje plik podany jako parametr programu na miejsce podane drugim parametrem

{Blockrd.PAS}

{Sample code for the BlockRead and BlockWrite procedures.}

program CopyFile;

{ Simple, fast file copy program with NO error-checking }

{ For Windows: }
{ uses WinCrt; }

var
FromF, ToF: file; {uchwyty do plikow}
NumRead, NumWritten: Word;
Buf: array[1..2048] of Char; {bufor, do ktorego beda trafialy wczytane dane z pliku pierwszego}
begin
Assign(FromF, ParamStr(1)); { Otwiera plik podany przez pierwszy parametr (zaraz za nazwa programu) }
Reset(FromF, 1); { Ilosc rekordow odczytywanych kazdorazowo = 1 }
Assign(ToF, ParamStr(2)); { Otwiera do zapisu plik podany drugim parametrem }
Rewrite(ToF, 1); { Record size = 1 }
Writeln('Copying ', FileSize(FromF), ' bytes...');
repeat
BlockRead(FromF, Buf, SizeOf(Buf), NumRead); {odczytywanie bloku o rozmiarze 2KB (NumRead teraz okresla rozmiar)}
BlockWrite(ToF, Buf, NumRead, NumWritten); {zapisywanie odczytanego bloku}
until (NumRead = 0) or (NumWritten <> NumRead); {kopiowanie do momentu skopiowania calego plikum lub gdy wystapi blad}
Close(FromF); {Zamykanie plikow}
Close(ToF);
end.

Dla bardziej ambitnych, których interesuje wczytywanie bitmapy 24bitowej, podaję wycinek kodu (cały moduł dostępny na tej

stronie). Korzysta on z wczesniej zdefiniowanych typów. Wczytuje bitmape do pamieci. Nie widac jej na ekranie. Wykorzystujac

poczatek tego kodu mozesz sprawdzic rozdzielczosc bitmapy oraz inne parametry. TBMPCaption to naglowek bitmapy. Kiedy

wczytujemy dane za pomoca BlockRead do jakiejs zmiennej okreslonego typu, odpowiednie bajty trafia do wlasciwych rekordow!

Oznacza to ze za pomoca jednego uzycia BlockRead, jesteśmy w stanie wczytac cały nagłówek bitmapy.

TYPE

TObraz=RECORD
W,
H : Word;
TCol : Word;
Transparent : Boolean;
BMP : Pointer;
BPP : Byte;
Paleta : Pointer;
END;

TPicture =^TObraz;

TBMPCaption = RECORD
BM : Word;
Size : Longint;
rezerw : Longint;
obraz_offset : Longint;
info : Longint;
Width : Longint;
Height : Longint;
LPO : Word;
BPP : Word;
kompresja : Longint;
Size_Obr : Longint;
HDPI : Longint;
VDPI : Longint;
Colors : Longint;
UColors : Longint;
END;

FUNCTION V_LoadBMP24(Buf:TPicture;CONST Fn:STRING):Boolean;
VAR
Capt : TBMPCaption;
F : FILE;
Size : Word;
Temp : Word;
I : Word;
BTem : Pointer;
Addx : Word;
BMPx : Pointer;
TC : Word;

BEGIN
{JESLI FUNKCJA SIE NIE ZAKONCZY POWODZENIEM ZWROCI False}
V_LoadBMP24:=False;

{JEZELI JESZCZE NIE MA UTWORZONEGO OBRAZKA TO WYCHODZI}
IF Buf=NIL THEN Exit;

{OTWIERA PODANY PLIK}
Assign(F, Fn);
{$I-}
Reset(F, 1);
{$I+}

{JESLI NIE ZNALEZIONO PLIKU WYCHODZI}
IF IOResult<>0 THEN Exit;

{WCZYTUJE NAGLOWEK INFORMACYJNY}
BlockRead(F, Capt, SizeOf(Capt));

{USTAWIA ROZMIAR OBRAZKA}
Buf^.W:=Capt.Width;
Buf^.H:=Capt.Height;

{OBLICZANIE POTRZEBNYCH PAMIECI DLA OBRAZKA}
{ORAZ DO BUFORA ODCZYTU Z DYSKU}
Size:=Capt.Width*Capt.Height SHL 1;
Temp:=Capt.Width SHL 1+Capt.Width;

{W RAZIE POTRZEBY PRZYDZIELA PAMIEC DLA RYSUNKU}
IF (Buf^.BMP=NIL) THEN
BEGIN
IF (MaxAvail>=Size) THEN GetMem(Buf^.BMP, Size)
ELSE Exit;
END;

{JEZELI TO NIE JEST BITMAPA 24 BITOWA}
IF Capt.BPP<>24 THEN BEGIN Close(F); Exit; END;

{PRZESTAWIA WSKAZNIK PLIKU NA POCZATEK BITMAPY}
Seek(F, Capt.Obraz_Offset);

{PAMIEC DO ODCZYTU JEDNEJ LINII}
IF MaxAvail Temp:=Temp+(Temp AND 3);
GetMem(BTem, Temp);

{USTAWIA WSKAZNIK BUFORU NA OSTATNIA LINIE}
Addx:=(Capt.Height-1)*(Capt.Width SHL 1);

{BUFOR POMOCNICZY DLA ASSEMBLERA}
BMPx:=Buf^.BMP;

{WCZYTUJE I PRZEKSZTALCA BITMAPE OD KONCA}
FOR I:=Capt.Height-1 DOWNTO 0 DO
BEGIN
BlockRead(F, BTem^, Temp);
ASM
Push Ds

Les Di, BMPx
Add Di, Addx

Lds Si, BTem

Mov Cx, Word Ptr Capt.Width

@Petla:

Xor Ax, Ax
Mov Al, [Si]
Inc Si

Xor Bx, Bx
Mov Bl, [Si]
Inc Si

Xor Dx, Dx
Mov Dl, [Si]
Inc Si

Shr Ax, 3
Shr Bx, 2
Shr Dx, 3

Shl Bx, 5
Shl Dx, 11

Or Ax, Bx
Or Ax, Dx

Mov Es:[Di], Ax

Inc Di
Inc Di

Dec Cx
Jnz @Petla

Pop Ds
END;
Dec(Addx, (Capt.Width shl 1));

END;

{OKRESLANIE KOLORU PRZEZROCZYSTEGO}
{LEWY GORNY PIKSEL}
ASM
Les Di, BMPx
Mov Ax, Es:[Di]
Mov Tc, Ax
END;

{DOMYSLNY KOLOR PRZEZROCZYSTOSCI}
Buf^.TCol:=Tc;

{ZWALNIA PAMIEC OD BUFORA}
FreeMem(BTem, Temp);

{ZAMYKA PLIK}
Close(F);

{ZAZNACZA ZE WSZYSTKO SIE UDALO}
V_LoadBMP24:=True;
END;