Wstęp

do programowania

Wykład 4

Operacje na plikach

Jeszcze o pętlach i typach

Program tablicezanków;

{$APPTYPE CONSOLE}
uses SysUtils;

Const max=58;
type Tznak = array[1..max] of char; {tablica jednowymiarowe znakowa }

var Znak :Tznak;

i:byte;

Begin

For i:=1 to max do

znak[i] := char(i+byte('A')-1);

For i:=1 to max do

write(znak[i]);

readln;

end.

Program tabice_liczowe;
{$APPTYPE CONSOLE}
Uses SysUtils;

Const N=5;
type TRtab = array[0..N ] of Single; {tablice 1 -wymiarowe}

TCtab = array[0..N] of SmallInt; // zmień typ

var C :TCtab;

R :TRtab;
Cp:TCtab=(0,-1,4,20,-5,6);

i:byte;

Begin
For i:=0 to N do

C[i]:=i; //wypełnianie automatyczne

For i:=0 to N do

begin
write('R[',i,']='); readln(R[i]); //czytanie z klawiatury
end;

For i:=0 to N do

writeln(C[i]); //wypisywanie

For i:=0 to N do

write(Cp[i]:4); writeln; //wypisywanie

For i:=0 to N do

writeln(R[i]:5:3); //wypisywanie + formatowanie

Readln; End.

Program macierze;
{$APPTYPE CONSOLE}
uses SysUtils;

Const N=4;
type TRMatrix = array[1..N,1..N ] of byte;

{tablice 2 -wymiarowe}

var M : TRMatrix;

i,j : byte;

Begin
For i:=1 to N do

For j:=1 to N do

M[i,j]:=i+j-1;

For i:=1 to N do

begin

For j:=1 to N do

write(M[i,j]:4);

writeln;

end;

Readln;
End.

program Sortowanie;
{$APPTYPE CONSOLE}
uses SysUtils;

const MaxN=4;
var

N :Integer;
A :array[1..MaxN] of Integer;
x :Integer;
i :1..MaxN+1;

begin
//Read(N, A[1],..., A[N]);

write('N=');readln(N);

//A[1]=_

for i := 1 to N do
begin

write('A[',i,']=');readln(A[i]);

end;

if N > 1 then

begin

i := 2;

repeat

repeat

while A[i] < A[i-1] do

begin

x := A[i];

A[i] := A[i-1];

A[i-1] := x;

if i > 2 then i := i-1;

end;

i := i+1;

until i > N;

end;

writeln('posortowane'); //

Write(A[1],.., A[N]);

for i := 1 to N do

begin

writeln('A[',i,']=',A[i]);

end;

readln; end.

Recordy

program Dane_rekordy;
{$APPTYPE CONSOLE}
uses SysUtils;

Type
Tdane

record

Imie : string[20];
Wiek : byte
Praca : array[1..10] of string

end;

var prac1, prac2 : TDane;

begin

prac1.imie

:=’Leon’;

prac1.wiek:=33;
prac1.praca[1]=

’Zakłady

energetyczny

’;

prac1.praca[2]=

’Siemens’;

prac2.imie:=’Daria’;

prac1.wiek:=27;

prac1.praca[1]=’Sąd rejonowy’;

//wypisz dane o pracownikach

Write(prac1.imie, prac1.wiek);
writeln(prac1.praca[1], prac1.praca[2]);

//instrukcja wiążąca with

With (prac2) do

Writeln(imie, wiek, praca[1], praca[2]);

end;

Readln;
End.

//Recordy

program pr_rekordy;
{$APPTYPE CONSOLE}
uses SysUtils;

Type
Tczas=record

godzina : 0..24;
minuta : 0..60;

End;
Tdata=record

czas:Tczas;

dzien : 1..31;

mies : 1..12;

rok : SmallInt;

End;

var data : Tdata;

begin

data.czas.godzina:=12;
data.czas.minuta:=30;
data.dzien:=5;
data.mies:=10;
data.rok:=2008;

//wypisz date

//instrukcja wiążąca with

With data do
begin

Write(

czas.godzina,’:’,czas.minuta

);

writeln(

dzien,’-‘,mies,’- ‘,rok);

end;

Readln;
End.

Cechy typu rekordowego

- rekordy mogą być zagnieżdżone, tzn pole rekordu może być

ponownie typu rekordowego, (struktura hierarchiczna);

-

pola tego samego typu mogą wystąpić oddzielone przecinkiem;

- dostęp do poszczególnych komponentów rekordu odbywa się

przy pomocy kropki oraz nazwy pola;

- podobnie jak w przypadku tablic zmienna rekordowa jako całość

nie może być parametrem procedur write i read,

- zmienne rekordowe mogą wystąpić w instrukcji przypisania pod

warunkiem, że są zdefiniowane tym samym typem;

- pola rekordów mogą występować we wszystkich operacjach,

jakie są dopuszczalne dla zadanego typu (typu pola), w szczególności
mogą być parametrami procedur lub funkcji;

- instrukcja wiążąca upraszcza dostęp do pól zmiennej rekordowej,

podobnie jak rekordy mogą być zagnieżdżone tak i instrukcja wiążąca
może być zagnieżdżona.

Pliki - struktury danych o elementach tego samego typu
• Typ elementów jest dowolnym typem poza typem plikowym lub

strukturalnym zawierającym elementy typu plikowego

• Zmienne plikowe reprezentują pliki fizycznych, które są zbiorami informacji

w pamięciach zewnętrznych

File of typ_danych

•

Dostęp do poszczególnych elementów pliku odbywa się sekwencyjnie,

w danym momencie dostępny jest co najwyżej jeden element pliku,
pozostałe elementy mogą być dostępne po wykonaniu pewnych operacji;
kolejność elementów w pliku zależy od kolejności w jakiej te elementy
zostały do pliku wpisane.

•

Liczba elementów pliku może być dowolna (jest ograniczona

pojemnością dysku)

Pliki

operacje wejścia / wyjścia

Schemat przetwarzania pliku

1. Deklaracja zmiennych plikowych
2. Skojarzenie zmiennej plikowej z plikiem fizycznym
3. Otwarcie pliku
4. Operacje na zawartości pliku fizycznego
5. Zamknięcie pliku

Rodzaje plików:

- pliki zdefiniowane (ich elementy są najczęściej typu rekordowego):

var zm_plik: file of typ;

- pliki tekstowe (składają się ze znaków o strukturze wierszowej):

var zm_plik: text; //

TextFile

- pliki beztypowe (traktowane są jako ciągi bajtów o niezdefiniowanej
strukturze):

var zm_plik: file;

Pliki

opracje wejścia / wyjścia

Zmienna wskazująca [wskaźnik położenia]

Jej zadaniem jest wskazywanie na odpowiednie miejsce w pamięci
buforowej komputera.
Zezwala na dostęp do każdego elementu w pliku i jest pośrednikiem
wszystkich wykonywanych na nim operacji.

Pliki zdefiniowane

var zm_plik : file of typ;

EOF (end of file)

wskaźnik położenia

0

1

2

3

4

5

6

7

8

9

1)

Każdy plik na dysku ma swoją unikalną nazwę, którą należy skojarzyć
ze zmienną plikową w programie

assignFile(

zm_plik

,‘nazwa_pliku');

Assign File (plik1

,‘c:\Dane\dane1.txt’);

AssignFile (plik2

,‘wynik.bin’);

2)

Otwarcie pliku może się odbyć na dwa różne sposoby:

a) do zapisu ze zniszczeniem zawartości pliku

rewrite(

zm_plik

);

b) do zapisu ze bez zniszczeniem zawartości pliku

Append(

zm_plik

);

(

dotyczy wyłącznie plików tekstowych (Text) i powoduje po otwarciu pliku

ustawienie zbioru na jego końcu)

c) od odczytu bez zniszczenia zawartości pliku reset(

zm_plik

);

We/Wy

3)

Plik można przetwarzać

Pliki tekstowe

a) zapisując do niego dane write(

zm_plik

, zmienna);

b) odczytując z niego dane read(

zm_plik

, zmienna);

c) zapisując do niego dane writeln(

zm_plik

, zmienna);

d) odczytując z niego dane readln(

zm_plik

, zmienna);

Binarne

a) zapisując do niego dane write(

zm_plik

, zmienna);

b) odczytując z niego dane read(

zm_plik

, zmienna);

4)

Po zakończeniu przetwarzania pliku należy go zamknąć

closeFile(

zm_plik

);

We/Wy

program Pliki1;
{$APPTYPE CONSOLE} {$O-,Q+,R+}
uses SysUtils;

var //f :File of DowolnyTyp;

f : File of real;
x : real;

begin

AssignFile(f

,'plik.bin'); //także 'c:\plik.bin'

Rewrite(f);

x := 3.14;
write(f,x);
x := -1.8;
write(f,x);
write(f,x,x);

// błąd writeln(f,x,x);

CloseFile(f);

readln;

end.

Przykład

: Tworzenie nowego pliku zawierającego kilka liczb

rzeczywistych

program Pliki2;
{$APPTYPE CONSOLE} {$O-,Q+,R+}

uses SysUtils;
var //f :File of DowolnyTyp;

f :File of real;
x :real;

begin

AssignFile

(f,'plik.bin'); //także 'c:/plik.bin'

Reset

(f);

while

not EoF(f)

do

begin

read(f,x);
writeln(x);

end;

CloseFile(f);

readln;

end.

Przykład

: Odczytywanie pliku zawierającego kilka liczb rzeczywistych .

program Pliki3;
{$APPTYPE CONSOLE} {$O-,Q+,R+}

uses SysUtils;
var

f :TextFile; //albo :Text

x :real;

begin

AssignFile(f,'plik.txt');

//'CON','PRN','LPT1','LPT2','AUX','COM1','COM2','NUL‘

//EoF(f) EoF== #26==^Z EoLn(f) EoLn=#13#10==^M^J

Rewrite(f);

x := 3.14;
writeln(f,x,' ',-x,' ', 2+2);
writeln(f,x,' ',-x:8:3,' ', 5);

CloseFile(f);

readln;

end.

Przykład

:

Zapis do pliku tekstowego dwóch liczb rzeczywistych i jednej

całkowitej.

program Pliki4;
{$APPTYPE CONSOLE} {$O-,Q+,R+}
uses SysUtils;
var

f :TextFile; //albo :Text
x, y :Real;
i :Integer;

begin

AssignFile(f,

'plik.txt');

Reset(f);

while not EoF(f) do

begin

readln(f,x,y,i);

writeln('x=',x,' y=',y,' i=',i);

end;

CloseFile(f);

readln;

end.

Przykład

: Odczytywanie z pliku tekstowego dwóch liczb rzeczywistych i

jednej całkowitej.

program UncWin;
{$APPTYPE CONSOLE} {$O-,Q+,R+}
uses SysUtils;

Var w,u :TextFile;

zn :char;

begin

AssignFile(u,'unx.txt');
AssignFile(w,'plik2.txt');
Reset(u);
Rewrite(w);

while not EoF(u) do
begin

read(u,zn);
if zn = #10 then

writeln(w)

else

write(w,zn);

end;
CloseFile(w);
CloseFile(u); //readln;

end.

Przykład

: Odczytywanie z pliku tekstowego dwóch liczb rzeczywistych

i jednej całkowitej.

program WinUnx;
{$APPTYPE CONSOLE} {$O-,Q+,R+}
uses SysUtils;

var w,u :TextFile;

zn :char;

begin

AssignFile(w,'plik.txt');
AssignFile(u,'unx.txt');

Reset(w);
Rewrite(u);

while not EoF(w) do
begin

read(w,zn);
if zn <> #13 then

write(u,zn);

end;

CloseFile(w);
CloseFile(u);
//readln;

end.

Przykład: Zapis i Odczytywanie z
pliku tekstowego liczb
całkowitych .

program wewy1;
{$APPTYPE CONSOLE} {$O-,Q+,R+}
Uses SysUtils;
Const N=5;
var we,wy :TextFile;

zn :char;

A, B: array[1..N]of Byte;

i:byte;

Begin
For i:=1 to N do A[i]:=10*i;

AssignFile(we,'Tplik.txt');

Rewrite(we);

For i:=1 to N do

Writeln(we,A[i]);

CloseFile(we);

AssignFile(wy,'Tplik.txt');

Reset(wy);
i:=1;

while (not EoF(wy))and(i<=N) do
begin

readln(wy,B[i]);

write(B[i]);
i:=i+1;

end;
CloseFile(wy); readln;
end.

program wewy2;
{$APPTYPE CONSOLE} {$O-,Q+,R+}
Uses SysUtils;
Var we1 :TextFile;

napis :string;

begin
AssignFile(we1,'wewy2.dpr');

Reset(we1);

While not EoF(we1) do

begin

readln(we1,napis);

if length(napis)<>0 then

if napis[1] in ['A'..'Z'] then

writeln(napis)

//wypisuje na ekranie tylko wiersze

// które zaczynają się z dużej litery

end;
CloseFile(we1);
readln;
End.

Przykład: Odczyt z aktualnego pliku łańcuchów tekstowych

Przykład

: Odczytywanie z pliku tekstowego dwóch liczb rzeczywistych

i jednej całkowitej.

program UnxWinStdIO;

{$APPTYPE CONSOLE} {$O-,Q+,R+}
uses SysUtils;

var

w,u :TextFile;
zn :char;

// UnxWinStdIO <unx.txt >plik3.txt

begin

while not EoF do
begin

read(zn);
if zn = #10 then

writeln //write(w,#13#10)

else

write(zn);

end;

end.