• Typy całkowite
Typy całkowite są podzbiorami zbioru liczb całkowitych. W zależności od zakresu, z czym związana jest liczba bajtów pamięci rezerwowanych dla zmiennych danego typu, wyróżnia się typy:
Integer -32 768 do 32 767 (zmienna zajmuje 2 B pamięci)
ShortInt -128 do 127 (1 B)
LongInt -2 147 483 648 do 2 147 483 647 (4 B)
Byte 0 do 255 (1 B)
Word 0 do 655 535 (2 B
• Typy rzeczywiste
Typy te są dyskretnym i skończonym podzbiorem zbioru liczb rzeczywistych. W Pascalu korzystać można z pięciu typów rzeczywistych o określonym zakresie:
Real 2.9e-39 do 1.7e38 (11-12 cyfr znaczących) (6B)
Single 1.5e-45 do 3.4e38 ( 7-8 cyfr znaczących) (4B)
Double 5.0e-324 do 1.7e308 (15-16 cyfr znaczących) (8B)
Extended 3.4e-4932 do 1e4932 (19-20 cyfr znaczących) (10B)
Comp około -9.2e18 do 9.2e18
Typ logiczny
Boolean
Wartości tego typu są oznaczone za pomocą dwu predefiniowanych literałów (stałych) : FALSE i TRUE, oznaczających odpowiednio wartości logiczne fałsz i prawda, przy czym w sensie uporządkowania słała FALSE poprzedza stałą TRUE. Liczbami porządkowymi elementów typu Boolean są tylko 0 (False) i 1(True). Typ Boolean jest jednym z typów wyliczeniowych,
• Typ znakowy
Char - elementami tego typu są znaki ASCII, z których każdy pamiętany jest w jednym bajcie pamięci.
• Typ wyliczeniowy
Jest stosowany zwykle dla zbiorów o niewielkiej liczbie elementów. Na
elementach typu wyliczeniowego nie wykonuje się operacji arytmetycznych. Porządek w tym typie jest zgodny z kolejnością wyliczenia w definicji typu. Elementy typu wyliczeniowego posiadają liczby porządkowe odpowiednio 0,1,2, ..itd.
Definicja :
type identyfikator_typu = (lista_identyfikatorów);
Lista identyfikatorów oddzielana jest przecinkami. Nazwy (identyfikatory) wyspecyfikowane w liście tworzą zbiór wartości danego typu wyliczeniowego .Istotne jest to, że ten sam identyfikator nie może być użyty do oznaczenia wartości w dwu różnych typach wyliczeniowych których wartości pokrywają się, w obrębie danego typu identyfikatory elementów muszą być różne. Przykład poprawnych definicji typu wyliczeniowego
type
dni_tygodnia = (poniedzialek, wtorek, sroda, czwartek,
piatek, sobota, niedziela);
niewiadome = (x,y,z);
wspolrzedne = (x1,y1,x2,y2);
• Typ okrojony
Typ okrojony ogranicza zbiór wartości dowolnego z typów porządkowych,
poprzez wyspecyfikowanie najmniejszej i największej dopuszczalnej wartości.
Definicja:
type identyfikator_typu = stala_1 .. stala_2;
Obie stałe muszą należeć do tego samego typu porządkowego, zwanego typem bazowym. Stała_1 podaje ograniczenie dolne i nie może być większa od sta-łej_2 - podającej ograniczenie górne.
Przykłady
type
znaki = 'a'..'z';
{ typ okrojony znaki jest podzbiorem
standardowego typu Char }
przedzial = 1..10
{ typ okrojony przedzial stanowi podzbiór
każdego ze standardowych typÛw całkowitych }
const
x = 20;
y = 30;
type
zakres = x+y..10*(x+y);
{ w definicji typu okrojonego
zastosowano wyrażenie stałe 10*(x+y) }
type
sprzet = (XT, 286, 386, 486, Pentium, PentiumII );
{ jest to typ wyliczeniowy }
dobry_sprzet = Pentium..PentiumII;
{ typ ten jest podzbiorem typu
wyliczeniowego sprzet }
• Typ łańcuchowy
Typ łańcuchowy służy do przechowywania tekstów.Elementami łańcucha mogą być dowolne znaki zbieżącej matrycy znaków komputera.
Definicja:
type identyfikator_typu : String;
identyfikator_typu : String[rozmiar];
Rozmiar jest stałą typu Byte. W pierwszym przypadku przyjmowany jest domyślnie największy możliwy rozmiar (256).
Przykłady:
type
wiersz = String [72];
napis = String;
im_naz = String[40];
• Typy strukturalne
Są to typy złożone, definiowane przez podanie typów składowych i metody
strukturalizacji. Metoda strukturalizacji określa sposób dostępu do elementów wartości strukturalnej.
Definicja :
type identyfikator_typu = opis_typu;
Wyróżnia takie typy strukturalne jak tablicowy, rekordowy, plikowy, zbiorowy, obiektowy, wskaźnikowy .
• Typ tablicowy
Tablica jest zbiorem elementów tego samego typu. Dostęp do poszczególnych elementów tablicy następuje za pomocą indeksu .
W przypadku tablic wielowymiarowych elementy tablicy identyfikowane są przez odpowiedni ciąg indeksów. W każdym przypadku indeks musi być typu porządkowego.
Definicja:
type
identyfikator_typu=Array[typ_indeksów] of typ_elementów;
Przykłady
type
wektor_1 = Array[1..10] of Real;
wektor_2 = Array[′a′..′d′] of Real;
macierz_1 = Array[0..10] of Array[30..40] of Integer;
macierz_2 = Array[1..10,30..40] of Integer;
• Typ rekordowy
Rekord składa się z elementów zwanych polami. Pola mogą być różnych typów, a dostęp do nich następuje poprzez wyspecyfikowanie odpowiednich identyfikatorów określonych w definicji typu rekordowego. Rekord może mieć kilka wariantów, z których każdy może posiadać różną liczbę pól. Dostęp do danego wariantu rekordu uzyskuje się poprzez wartość tzw. pola znacznikowego, wspólnego dla wszystkich wariantów.
Definicja:
type identyfikator_typu = record
lista_deklaracji_pÛl
end;
Przykłady
type data = record
dzien : 1..31;
miesiac : 1..12;
rok : Word
end;
type punkt =record
numer : Word;
x,y,z : Real;
opis : String[40]
end;
• Typ zbiorowy
Elementami zbioru są wszystkie podzbiory pewnego typu porządkowego,
zwanego typem bazowym, określanego w definicji zbioru. Typ bazowy nie może
przekraczać liczby 256 elementów. Definicja:
type identyfikator_typu = set of typ_porządkowy;
Przykłady
type
weekend = (sobota, niedziela); { typ wyliczeniowy }
wyjazdy = set of dzien; { typ zbiorowy }
• Typ plikowy
Plik reprezentuje dane przechowywane w pamięci dyskowej. Plik jest ciągiem elementów tego samego typu. Dostęp do elementów typu plikowego jest sekwencyjny, w danej chwili dostępny jest tylko jeden element pliku.
Definicja:
type
identyfikator_typu = file;
{ elementy typu plikowego niezdefiniowane }
type
identyfikator_typu = file of opis_typu_;
{ plik zdefiniowany, elementowy }
type
identyfikator_typu = Text; { plik tekstowy }
Przykłady
type
dowolny_plik = File;
dane = Text;
znaki = file of Char;
daty = file of record
dzien :1..31;
miesiac : 1..12;
rok : Word;
end;
• Typ obiektowy
Obiekt jest strukturą składającą się ze stałej liczby elementów, z których
każdy jest polem określonego typu lub metodą (procedurą lub funkcją), która określa operacją wykonywaną na obiekcie. Typ obiektowy może dziedziczyć elementy innego typu obiektowego.
• Typ wskaźnikowy
Typ wskaźnikowy jest związany ze zmiennymi dynamicznymi.
Zmienne statyczne są to zmienne deklarowane w programie, posiadające określony identyfikator i istniejące w obrębie określonej części programu. Zmienne dynamiczne mogą być wygenerowane w wyniku realizacji jednej z instrukcji
i nie posiadające identyfikatorów. Pamięć dla zmiennych dynamicznych jest przydzielana i zwalniana podczas wykonywania programu, na żądanie określone przez programistę. Dostęp do zmiennych dynamicznych jest możliwy poprzez tzw.wskaźniki, które określają adresy tych zmiennych w pamięci i które są tworzone w chwili ich generowania.
Typ wskaźnikowy jest zbiorem wartości wskaźników, a każda zmienna typu
wskaźnikowego jest w chwili deklaracji wiązana z pewnym typem i może przyjmować wartości (wskaźniki) tylko tego typu.
Typy proceduralne
Procedury i funkcje mogą być traktowane jako elementy, które mogą być przypisywane zmiennym i przekazywane do innych funkcji i/lub procedur jako parametry. Wymaga to zadeklarowania odpowiednich zmiennych, a wcześniej zdefiniowania odpowiedniego typu proceduralnego.
type nazwa = procedure(lista_parametrow);
lub
type nazwa = function {lista_paramatrow} : typ_wartsci_funkcji;
Deklaracja zmiennych
Zmienną nazywamy daną, która w ramach określonego typu może przyjmować różne wartości. wymagana jest deklaracja wszystkich zmiennych statycznych . Deklaracje zmiennych muszą poprzedzać pierwsze wystąpienia zmiennych.
Zmienne mogą być deklarowane w części opisowej programu (zmienne globalnie) lub wewnątrz procedur i funkcji (zmienne lokalne). Miejsce deklaracji zmiennej ustala jej zakres działania, tzn. ustala dla określonej danej te fragmenty tekstu programu, w których dana jest dostępna poprzez swój identyfikator. Zakresem zmiennych globalnych jest cały program, z wyjątkiem procedur i funkcji, w których ten sam identyfikator został użyty do oznaczenia zmiennej lokalnej. Zakres zmiennych lokalnych obejmuje procedurę lub funkcję w której dane zostały określone. W zależności od miejsca zadeklarowania zmiennej w różny sposób przydzielana jest dla niej pamięć. Zmienne globalne umieszczane są w segmencie danych, natomiast zmienne lokalne w segmencie stosowym. Dla segmentu danych pamięć jest przydzielana w momencie rozpoczęcia wykonywania programu i aż do jego zakończenia rozmiar tej pamięci nie ulega zmianie (max. 65520 bajtÛw).Segment stosowy (stos) może mieć rozmiar od 1024 do 65520 bajtÛw. Pamięć na stosie jest przydzielana zmiennym lokalnym przed każdym wywołaniem funkcji
lub procedury, a po zakończeniu wykonywania funkcji lub procedury pamięć ta jest zwalniana.
Deklaracje zmiennych składają się ze słowa kluczowego var, po którym następuje
wykaz deklaracji.
var
identyfikator_zmiennej : typ_zmiennej;
lub
identyfikator_zmiennej : opis_typu_zmiennej;
lub
lista_identyfikatorow_oddzielona_przecinkami :typ_zmiennych;
lub
lista_identyfikatorow_oddzielona_przecinkami :opis_typu_zmiennej;
Przykłady:
const N = 30; { definicja stałej }
type opis = record { definicje typow }
Lp : Byte;
Imie, Nazwisko : String[20]
end;
wykaz = Array[1..N] of opis;
macierz = Array[1..10, 1..50] of Real;
var i: : Integer; { deklaracje zmiennych }
a,b,suma : Real;
koniec: : Boolean;
kolor: : (zolty, niebieski, zielony);
barwa : set of kolor;
zakres : 1..25;
f : Text;
dane : Macierz;
student : opis;
lista : wykaz;
zbior : record
wydzial : record
kierunek : String;
rok : 1..5;
end;
grupa : wykaz;
end;
Zmienne całościowe
Nazwa zmiennych całościowych składa się z samego identyfikatora.
Przykłady
var licznik : Integer;
znak : Char;
a,b,c : Real;
begin
licznik:=1;
znak:=’x’;
a:=2;
b:=5;
c:=a/b;
end.
Zmienne indeksowane
służą do odwołania się do elementów zmiennej typu tablicowego oraz do odwoływania się do pojedynczych znaków zmiennych łańcuchowych. Indeks jest dowolnym wyrażeniem którego wartość jest zgodna z typem indeksowym. W przypadku odwoływania się do zmiennych łańcuchowych, zmienna indeksowana może posiadać tylko jeden indeks o wartości od 0 do n, gdzie n -zadeklarowana długość łańcucha. Wartość zmiennej jest (Char).
Przykłady:type
Wektor = Array[0..5] of Word;
Macierz = Array[0..10, 0..10] of Real;
Napis = String[20];
var
w : Wektor;
m : Macierz;
nazwa : Napis
element : Real;
znak : Char;
begin
{...}
w[0]:=0;
element:=m[1][8] := 10.23;
element:=m[1,2*4] := 10.23;
end.
Zmienne rekordowe
Są to zmienne których wartości są typu rekordowego. Aby odwołać się do
pola rekordu, należy za identyfikatorem zmiennej rekordowej podać tzw. desygnator pola postaci:
.identyfikator_pola
Przykłady:
type opis = record
Lp : Byte;
Imie, Nazwisko : String[20]
end;
wykaz = Array[1..N] of opis;
var i: : Integer; { deklaracje zmiennych }
student : opis;
lista : wykaz;
zbior : record
wydzial : record
kierunek : String;
rok : 1..5;
end;
grupa : wykaz;
end;
Odwołania do pól Lp, Imie, Nazwisko zmiennej rekordowej student powinny mieć postać: student.Lp student.Imie
student.Nazwisko
W przypadku zmiennej lista, która jest tablicą rekordów, odwołania do poszczególnych pól rekordu mają postać
lista[i].Lp lista[i].Imie
lista[i].Nazwisko
gdzie lista[i] oznacza i-ty element tablicy lista.W przypadku zmiennej rekordowej zbiór, elementy zmiennej są typu odpowiednio rekordowego i tablicowego. Odwołanie
zbior.wydział jest odwołaniem do wszystkich elementów pola wydział.
zbior.grupa
oznacza odwołanie do całej tablicy rekordów grupa. Dostęp do pola kierunek lub rok rekordu wydział uzyskamy za pomocą specyfikacji:
zbior.wydzial.kierunek
zbior.wydzial.rok
Dostęp do pola Lp, Imie lub Nazwisko w i-tym elemencie tablicy grupa uzyskamy za pomocą : zbior.grupa[i].Lp
zbior.grupa[i].Imie
zbior.grupa[i].Nazwisko
Zmienne absolutne
Są to zmienne którym adres pamięci przydziela programista. Deklaracja zmiennej absolutnej ma postać:
var identyfikator_zmiennej :
opis_typu absolute segment:offset
lub
var identyfikator_zmiennej :
opis_typu absolute identyfikator_zmiennej;
Występująca w deklaracji dyrektywa absolute określa deklarowany identyfikator jako zmienną absolutną. Segment i offset,, są liczbami całkowitymi i powinny należeć do przedziału (od 0 do 65535 w zapisie dziesiętnym). Pierwsza liczba określa adres segmentu,druga adres względny (ang. offset) w ramach tego segmentu.
Przykład:
var tryb : Byte absolute $0080:$0089
var bufor : Array[1..100] of record
Lp : Byte;
znak : Char;
end absolute $B050:$0000;
var
napis : String[50];
dlugosc_napisu : Byte absolute napis;
Zmienna absolutna dlugosc_napisu jest zmienną typu Byte.
Literały zmiennych
jest pośrednim elementem pomiędzy stałą i zmienną. mogą być uważane za zmienne którym nadano wartość początkową. W programie, literały zmienne mogą zmieniać swoją wartość. Różnica względem zmiennych polega na tym że w wyniku
ponownego uruchomienia programu znajdującego się w pamięci operacyjnej zachowywane są wartości literałów zmiennych z poprzedniego wykonania. Również literały zmienne deklarowane w procedurach i funkcjach nie są reinicjowane.
Oznacza, to że przy ponownym wywołaniu procedury lub funkcji literały zmienne
posiadają wartości z poprzedniego wywołania.Definicja
const identyfikator_literału : oznaczenie_typu = stała
Oznaczenie typu jest identyfikatorem typu lub opisem typu (mogą to być typy: prosty, łańcuchowy, obiektowy, proceduralny lub wskaźnikowy).Stała może być wyrażeniem stałym, stałą tablicową, rekordową, obiektową, zbiorową, proceduralną lub stałym wyrażeniem adresowym.
• Wyrażenie stałe jest to wyrażenie, które może być obliczone przez kompilator. wyrażenie stałe nie może zawierać zmiennych, literałów zmiennych z wyjątkiem literałów którym przypisano stałe wyrażenia adresowe, wywołań funkcji za wyjątkiem niektórych funkcji standardowych oraz operatora adresowego@. Przykład:
const
znak : Char = 'x';
napis : String[10] = 'Wtorek';
liczba : Byte = 21;
• Stała tablicowa jest w ogólności ciągiem stałych ujętych w nawiasy okrągłe.
Poszczególne stałe oddzielane są przecinkami. Stałe tablicowe znakowe mogą
być podane również jako łańcuchy
Przykład:
const znaki_1 : Array[1..5] of Char = ('1','a','b','$');
znaki_2 : Array[1..5] of Char = '12ab$';
Powyższe definicje opisują rÛwnoważne literały zmienne, będące tablicami znakowymi.
Const macierz_pozioma :
Array[1..2,1..3] of Byte = ((1,2,3),(4,5,6));
macierz_pionowa :
Array[1..3,1..2] of Byte = ((1,2),(3,4),(5,6));
Stała rekordowa jest ciągiem elementów oddzielonych średnikami. Każdy
element ma postać:
identyfikator_pola : stała_typowa;
Pola powinny być wyspecyfikowane w takiej kolejności jak występują w definicji
danego typu rekordowego.
Przykład:
type punkt = record
Nr : Byte;
x,y : Real;
end;
odcinek = Array[1..2] of punkt;
const dane : punkt = (Nr:12 ; x:20.20 ; y:30.30);
rysuj : odcinek =( ( Nr:1 ; x:1.0 ; y:1.0) ,
( Nr:2 ; x:20.0 ; y:30.0));
Stała zbiorowa jest ujętym w nawiasy kwadratowe ciągiem elementów zbioru
oddzielanych przecinkami. Definicja literału zmiennego typu zbiorowego może
również określać zbiór pusty [].
Przykłady:
type
kolory : (zolty, niebieski, zielony);
barwa : set of kolory;
const
kolor : barwa = [niebieski, zielony];
nieznany_kolor : barwa = [];
type
cyfry = set of 0..9;
const
nieparzyste : cyfry = [1,3,5,7,9];
Definicje procedur i funkcji
Funkcja lub procedura jest wyodrębnioną częścią algorytmu, posiadając
jednoznaczną nazwę i ustalony sposób wymiany informacji z pozostałymi częściami programu. Zadaniem funkcji jest obliczenie jednej wartości, która jest podstawiana pod nazwę funkcji. W przypadku procedury może być obliczana jest jedna lub kilka wartości, które są przypisywane odpowiednim parametrom procedury.
Przykłady
Procedure nazwa1(lista_parametrów_formalnych)
{ część opisowa procedury }
begin
{ część wykonanwcza procedury }
end;
function nazwa2(lista_parametrów_formalnych): typ_funkcji;
{ cz••• opisowa funkcji }
begin
{ cz••• wykonanwcza funkcji }
druga:=wyrazenie;
{ podstawienie pod nazwę funkcji wyrazenia zgodnego z typem funkcji }
end;
Definicje obiektów
Obiekt jest specjalnym połączeniem danych i metod (funkcji i procedur) operujących na nich.
WYRAŻENIA
Wyrażenie jest zapisem algorytmu określającego sposób obliczenia pewnej wartości. Na wyrażenie składa się kombinacja operatorów i operandów (argumentów operacji, czyli stałych zmiennych i nazewników - inaczej nazw funkcji). Wyrażeniami są również
wyrażenia połączone operatorami relacyjnymi (są to tzw. wyrażenia porównania).Wyrażenia nie stanowią samoistnych instrukcji, są ich częścią składową.
Operatory arytmetyczne
stosowane są do obliczania wartości liczbowych. występują operatory, których argumenty oraz wynik mogą być typu całkowitego lub rzeczywistego:+ (dodawanie, identyczność),- (odejmowanie, zmiana znaku),* (mnożenie),
/ (dzielenie),oraz operatory, których argumenty oraz wynik mogą być tylko typu całkowitego:div (dzielenie całkowite)mod (reszta z dzielenia )
Operatory logiczne
Stosowane są do wykonywania operacji logicznych na wartościach typu Boolean oraz na wartościach całkowitych.
not (negacja)
and (koniunkcja)
or (alternatywa)
xor (różnica symetryczna)
Argumenty operatorów mogą być całkowite lub logiczne, natomiast
wyniki są typu całkowitego lub Boolean.
Operatory relacyjne
Stosowane są do konstrukcji wyrażeń porównania.
= (równy)
<> (nierówny)
< (mniejszy)
> (większy)
<= (nie większy lub jest zawarty)
>= (nie mniejszy lub zawiera)
in (jest elementem)
Wynik wyrażenia porównania jest typu Boolean i posiada wartość True, gdy relacja jest prawdziwa oraz wartość False, gdy relacja jest fałszywa.
Operatory teoriomnogościowe
Operatory te to to suma (+), różnica (-) i iloczyn (*) zbiorów. Operacje te mogą
być wykonywane na argumentach typu zbiorowego o zgodnych typach bazowych.
Operator konkatenacji
Operator konkatenacji (+) służy do połączenia dwóch lub więcej łańcuchów w jeden łańcuch. Wynik jest typu String. Jeżeli łańcuch wynikowy jest dłuższy niż 255
znaków, to dalsze znaki zostaną obcięte.
Operator @
Jednoargumentowy operator @ służy do utworzenia adresu podanego argumentu. Argument może być zmienną, nazwą funkcji, nazwą procedury lub nazwą metody.Wartość wyrażenia @ argument jest typu wskaźnikowego.
Priorytet operatorów
Najwyższy priorytet mają operatory oznaczone przez 1, najniższy operatory o prorytecie 4.
+,-, @, not -jednoargumentowy 1
*, /, div, mod, and, shl, shr -multiplikatywny 2
+, -, or, xor addytywny 3
=, <, <, , <=, =, in relacyjny 4
Zasady dodatkowe:
Operacje o równym priorytecie wykonywane są zazwyczaj od lewej do prawej strony wyrażenia.
Argument znajdujący się pomiędzy operatorami o jednakowym priorytecie związany jest z operatorem znajdującym się z lewej strony, Argument występujący pomiędzy operatorami o różnych priorytetach związanyjest z operatorem o wyższym priorytecie,
W pierwszej kolejności wykonywane są działania występujące w nawiasach okrą-
głych.
Przykłady wyrażeń i operatorów
program wyrazenia;
const napis_1 = ’Informatyka’;
type kolor = (zielony, niebieski, bialy, czarny);
var a,b : Real;
i : Integer;
j : Word;
OK,p,q : Boolean;
r,s,t : Integer;
x,y,z : Real;
zbior_kolorow : Set of kolor;
napis_2 : String;
adres : Pointer;
begin
{ operatory arytmetyczne }
a:=1.0;
b:=12;
i:=10;
j:=3;
p:=TRUE;
q:=FALSE;
x:=a+b; { 13.0 }
y:=a-b*(i+j); { -15.5 }
z:=0.3 * (2*(a/b)*(j-1)); { 0.1 }
r:=i div j; { 3 }
s:=i mod j; { 1 }
Write(r*(s+1)); { 6 }
{ operatory logiczne }
OK:=not(p); { FALSE }
OK:=p and q; { FALSE }
OK:=p or q; { TRUE }
OK:=p xor q; { TRUE }
OK:=p xor p; { FALSE }
{ operatory relacyjne }
OK:=a+b >= 0; { TRUE }
OK:='abc' > 'def'; { FALSE }
OK:='a' < 'bc'; { TRUE }
OK:= zielony in zbior_kolorow; { FALSE }
OK:= zbior_kolorow = [zielony..czarny]; { FALSE }
OK:= zbior_kolorow = [zielony..niebieski];{ FALSE }
{ operatory teoriomnogo•ciowe }
zbior_kolorow:=zbior_kolorow - [niebieski];
zbior_kolorow:=zbior_kolorow * [];
{ operator konkatenacji }
napis_1:= 'Przedmiot ' + napis_1 + ' ROK I';
{ operator @ }
adres:=@x;
{ ...}
end.
Instrukcja przypisania
Instrukcja przypisania := służy do przypisania zmiennej pewnej wartości.Ogólna postać instrukcji przypisania:
odwołanie_do_zmiennej := wyrażenie;
lub nazwa_funkcji := wyrażenie;
Wartość wyrażenia musi być zgodna w sensie przypisania - w pierwszym przypadku z typem zmiennej, - w drugim przypadku z typem funkcji.
Przykłady:
i:=1;
x:=5*i+10.0;
macierz[i,25+j]:=z*z+wektor[k];
koniec := a+b>c
wykaz[i].kierunek.grupa[j]:='Kowalski';
{ na podstawie powyższych instrukcji można określić,
jakich typów muszą by poszczególne zmienne }
Instrukcja pusta
Nie powoduje wykonania żadnej czynności, a jej zapisanie nie
wymaga użycia żadnego symbolu języka. Najczęściej,stosuje się ją
w celu ułatwienia opracowywania programu.
Przykład
if i>j then i:=j else ; { instrukcja pusta występuje po else }
Instrukcja skoku
Powoduje przejście do instrukcji programu poprzedzonej etykietą.
Ogólna postać instrukcji skoku:
goto etykieta;
Instrukcja poprzedzona etykietą może występować przed lub po odnośnej instrukcji skoku, przy czym obie instrukcje muszą występować w tym samym bloku. Nie jest dozwolony skok do wnętrza lub na zewnątrz procedury lub funkcji. Stosowanie instrukcji skoku powoduje m.inn. zmniejszenie przejrzystości
programu, ogranicza optymalizację kodu wynikowego, utrudnia analizę programu.
Przykład
program etykieta;
{ ... }
label 123, koniec;
var znak : Char;
begin
{ ...}
123 : instrukcja;
if znak='K' then goto koniec
else goto 123;
{ ... }
koniec : halt;
end;
Instrukcja wywołania procedury
Wywołanie procedury następuje za pomocą podania nazwy procedury.
Jeśli procedura zawiera parametry, to bezpośrednio za nazwą procedury podaje się
w nawiasach okrągłych listę argumentów, przy czym poszczególne argumenty oddziela się przecinkami.
Przykłady:
Write(' Podaj wartość zmiennej X);
Readln(x);
oblicz(a,b,c,delta); { procedura oblicz musi być wcześniej zdefiniowana }
Instrukcja inline
Instrukcja i dyrektywa inline służy do dołączania w programach
krótkich podprogramów lub instrukcji napisanych w kodzie
maszynowym (asemblerze).
Postać dyrektywy i instrukcji inline:
inline(lista_elementów_kodu)
Przykład:
inline($CD/$05);
Wywołanie powyższej instrukcji spowoduje przesłanie aktualnej zawartości pamięci obrazu (ekranu) do drukarki i jej wydrukowanie
Instrukcja złożona
Jest ciągiem instrukcji poprzedzonych słowem kluczowym
begin i zakończonym słowem kluczowym end.
Składnia instrukcji złożonej:
begin
instrukcja_1;
instrukcja_2;
{ ...}
end;
Przykład:
begin
a:=4.5;
x:=18;
dane:='macierz.txt'
end;
Instrukcje warunkowe
: instrukcja instrukcja if (jeśli) oraz instrukcja case (wyboru).
Instrukcja if ... then ... else ...; (Instrukcja jeśli)
Instrukcja ta uzależnia wykonanie innej (innych) instrukcji od spełnienia lub niespełnienia podanego warunku.
Składnia:
if wyrażenie then instrukcja;
lub
if wyrażenie then instrukcja
else instrukcja;
Wartością wyrażenia jest wartość logiczna True lub False. Jeśli wartość wyrażenia
jest True, to zostanie wykonana instrukcja podana po słowie then, w przeciwnym
razie następna instrukcja, a jeżeli występuje słowo else - instrukcja po słowie else.
Przykłady:
if x>0 then y:=1;
if (x>0) or (y<1) then z:=3
else
begin
z:=2;
y:=z+1
end;
Instrukcje warunkowe if mogą być zagnieżdżane, tzn. po słowach then i/lub else mogą występować kolejne instrukcje jeśli.
W instrukcji zagnieżdżonej, każda jednostka else jest przyporządkowana najbliższej poprzedzającej ją jednostce then, dla której jednostka else jeszcze nie wystąpiła.
Przykłady:
if x>0 then if y>0 then z:=1;
Bardzo często instrukcję jeśli można zapisać w kilku postaciach:
• if x>=0 then p:=1;
if (x<0) then if (y<0) then if (z<0) then p:=0;
• if x>=0 then p:=1;
if (x<0) and (y<0) and (z<0) then p:=0;
• if (x<0) then if (y<0) then if (z<0) then p:=0
else
else
else p:=1;
• if (x<0) then if (y<0) and (z<0) then p:=0
else
else p:=1;
Instrukcja case ... of ... else ...end; (Instrukcja wyboru)
Wykonanie konkretnych instrukcji jest uzależnione od wartości pewnej zmiennej (selektora).
Składnia:
case selektor of
stała_wyboru: instrukcja;
...
stała_wyboru,stała_wyboru: instrukcja
end;
lub
case selektor of
stała_wyboru: instrukcja;
...
stała_wyboru,stała_wyboru: instrukcja
else
instrukcja
end;
Wyrażenie (selektor) musi być typu porządkowego.Instrukcje wyboru mogą być poprzedzone jedną lub kilkoma stałymi wyboru.
Poszczególne stałe wyboru oddzielane są przecinkami. Stałe wyboru oddzielane są dwukropkiem od instrukcji wyboru.
Przykład
case znak of
'A'..'Z', 'a'..'z' : Writeln('litera');
'0'..'9' : Writeln('cyfra');
'+', '-', '*', '/' : Writeln('operator');
else
Writeln('znak specjalny');
end;
Instrukcje iteracyjne
Służą do wielokrotnego wykonywania pewnych sekwencji instrukcji. Są to instrukcje: for (dla), repeat (powtarzaj) oraz while (dopóki).
Instrukcja for..to, for...downto (Instrukcja dla)
Stosowana jest najczęściej dla wielokrotnego wykonania grupy instrukcji gdy znana jest liczba powtórzeń. Składnia
for zmienna := mniejsza to wieksza do instrukcja
lub
for zmienna := wieksza downto mniejsza do instrukcja
Parametr zmienna oraz wartość inicjująca i kończąca instrukcję muszą należeć do
jednego z typów porządkowych.
Przykłady
for i := 1 to N do Writeln(i);
for i := 1 to 10 do
for j := 1 to 10 do
begin
x := 0;
for k := 1 to 10 do
x := x + macierz_1[i,j] * macierz_2[k,j];
macierz[i,j] := x
end;
for znak:='z' downto 'a' do Writeln(znak);
Instrukcja repeat...until (Instrukcja powtarzaj)
Instrukcja ta służy do wykonywania obliczeń iteracyjnych ze sprawdzaniem warunku na końcu instrukcji. Instrukcje zawarte pomiędzy repeat i until są sekwencyjnie wykonywane dopóki wyrażenie logiczne po słowie kluczowym until nie osiągnie wartości True. Ponieważ warunek sprawdzany jest na końcu instrukcji, instrukcje zamieszczone pomiędzy słowami kluczowymi repeat i until wykonają się zawsze przynajmniej jeden raz.
Składnia:
repeat
instrukcja;
instrukcja;
...
instrukcja
until wyrażenie;
Przykłady
repeat
Readln(liczba)
until liczba=0;
repeat
Write('Wprowadź liczbę całkowitą: ');
Readln(liczba)
until (liczba >= 0) and (liczba <=9);
Instrukcja while ...do ...; (Instrukcja dopÛki
Instukcja ta służy do opisywania iteracji ze sprawdzeniem warunku na początku instrukcji
Składnia
while wyrażenie do instrukcja
Instrukcja występująca po słowie do jest wykonywana tak długo, jak długo wyrażenie logiczne po słowie while ma wartość True. Jeżli warunek występujący
po słowie while. Ponieważ warunek sprawdzany jest na początku instrukcji, instrukcja zamieszczona po słowie do może być w ogóle nie wykonywana.
Przykłady
while liczba <>0 do Readln(liczba);
while (liczba < 0) and (liczba >9) do
begin
Write('Wprowadź liczbę całkowitą: ');
Readln(liczba) end;
Instrukcja wiążąca with ... do..;
Zastosowanie instrukcji wiążącej with pozwala na wygodniejsze odwoływanie się do pól rekordów lub obiektów. Zastosowanie tej instrukcji zwiększa też czytelność
programu.
Składnia:
with lista_zmiennych do instrukcja
Przykłady
with data[i] do
begin
miesiac := 1;
rok := rok + 1;
end;
Powyższy zapis jest równoważny instrukcjom:
data[i].miesiac := 1;
data[i].rok := data[i].rok + 1;
Procedury i funkcje
Definicje procedury i funkcji mają następujące postacie ogólne:
procedure identyfikator_procedury ( lista_parametrów_formalnych);
{ część_opisowa }
begin
{ ciąg_instrukcji }
end;
function identyfikator_funkcji (lista_parametrów_formalnych): typ_wyniku;
{ część_opisowa }
begin
{ ciąg_instrukcji }
end;
• parametry przekazywane przez wartości,
• parametry przekazywane przez zmienne określonego typu,
• parametry przekazywane przez zmienne nieokreślonego typu.
Deklaracje tych parametrów mają postać odpowiednio:
lista_parametrów:identyfikator_typu
var lista_parametrów : identyfikator_typu
var lista_parametrów
Różnica pomiędzy procedurą i funkcją polega na sposobie przekazywania wartości określanej przez procedurę
(funkcję). Zadaniem procedury jest wykonanie pewnej sekwencji czynności, polegających zwykle na obliczeniu jednej lub wielu wartości. Z identyfikatorem procedury związany jest adres, gdzie się ona znajduje. Natomiast
zadaniem funkcji jest obliczenie jednej wartości (typu prostego lub wskaźnikowego). Oprócz adresu posiada ona również identyfikator informujący o wyznaczonej wartości. Odmienne są też sposoby wywołania procedur i funkcji. Procedury wywołuje się przez nazwę (podając ewentualnie listę parametrów formalnych), funkcję zaś podstawia się pod zmienną typu zgodnego z typem funkcji. W przypadku funkcji, w ciągu instrukcji musi wystąpić
przynajmniej jedna instrukcja przypisania postaci:
indentyfikator_funkcji := wyrażenie
Procedury i funkcje bezparametrowe
W przypadku procedur (funkcji) bezparametrowych, korzystają one ze zmiennych globalnych
zadeklarowanych w programie lub modułach.
Przykład 1.
Wprowadzenie do programu dwóch macierzy A i B, obliczenie macierzy C jako sumy A+B, a następnie wypisanie wartości wszystkich trzech macierzy na ekranie monitora
Wersja 1.
program procedury_bez_parametrow_formalnych;
uses Crt;
const maxW=10; maxK=5;
type macierz=Array[1..maxW,1..maxK] of Real;
var A,B,C:Macierz; W,K:Word;
procedure czekaj;
var znak:Char;
begin
Write(' ... nacisnij dowolny klawisz ...');
znak:=Readkey
end;
procedure czytaj_WK;
var i,j:Word;
begin
Repeat
Write('Podaj liczbe wierszy (W<=',maxW,') W = ');
Readln(W);
Until W<=maxW;
Repeat
Write('Podaj liczbe kolumn (K<=',maxK,') K = ');
Readln(K);
Until K<=maxK;
end;
procedure czytaj_macierz_A;
var i,j:Word;
begin
Writeln('Wprowadz elementy macierzy A');
for i:=1 to W do
for j:=1 to K do
begin
Write('A[',i:2,',',j:2,'] = ');
Readln(A[i,j]);
end;
end;
procedure czytaj_macierz_B;
var i,j:Word;
begin
Writeln('Wprowadz elementy macierzy B');
for i:=1 to W do
for j:=1 to K do
begin
Write('B[',i:2,',',j:2,'] = ');
Readln(B[i,j]);
end;
end;
procedure dodaj;
var i,j:Word;
begin
for i:=1 to W do
for j:=1 to K do C[i,j]:=A[i,j]+B[i,j];
end;
procedure wypisz_A;
var i,j:Word;
begin
Writeln(' Macierz A');
for i:=1 to W do
begin
for j:=1 to K do Write(A[i,j]:10:2);
Writeln;
end;
end;
procedure wypisz_B;
var i,j:Word;
begin
Writeln(' Macierz B');
for i:=1 to W do
begin
for j:=1 to K do Write(B[i,j]:10:2);
Writeln;
end;
end;
procedure wypisz_C;
var i,j:Word;
begin
Writeln(' Macierz C = A + B ');
for i:=1 to W do
begin
for j:=1 to K do Write(C[i,j]:10:2);
Writeln;
end;
end;
begin
czytaj_WK;
czytaj_macierz_A;
czytaj_macierz_B;
dodaj;
wypisz_A;
wypisz_B;
wypisz_C;
czekaj;
end.
wersja 2.
program procedury_z_parametami_przekazywanymi_przez_wartosc;
uses Crt;
const maxW=10;
maxK=5;
type macierz=Array[1..maxW,1..maxK] of Real;
var A,B,C:Macierz;
W,K:Word;
procedure czekaj;
var znak:Char;
begin
Write(' ... nacisnij dowolny klawisz ...');
znak:=Readkey;
end;
procedure czytaj_WK;
begin
Repeat
Write('Podaj liczbe wierszy(W<=',maxW,') W = ');
Readln(W);
Until W<=maxW;
Repeat
Write('Podaj liczbe kolumn (K<=',maxK,') K = ');
Readln(K);
Until K<=maxK;
end;
procedure czytaj_macierz_A;
var i,j:Word;
begin
Writeln('Wprowadz elementy macierzy A');
for i:=1 to W do
for j:=1 to K do
begin
Write('A[',i:2,',',j:2,'] = ');
Readln(A[i,j]);
end;
end;
procedure czytaj_macierz_B;
var i,j:Word;
begin
Writeln('Wprowadz elementy macierzy B');
for i:=1 to W do
for j:=1 to K do
begin
Write('B[',i:2,',',j:2,'] = ');
Readln(B[i,j]);
end;
end;
procedure dodaj;
var i,j:Word;
begin
for i:=1 to W do
for j:=1 to K do C[i,j]:=A[i,j]+B[i,j];
end;
procedure wypisz(tablica:macierz;opis:String);
{parametry: tablica i opis przekazywane sa przez wartosc }
var i,j:Word;
begin
Writeln(opis);
for i:=1 to W do
begin
for j:=1 to K do Write(tablica[i,j]:10:2);
Writeln;
end;
end;
begin
czytaj_WK;
czytaj_macierz_A;
czytaj_macierz_B;
dodaj;
wypisz(A,'Macierz A');
wypisz(B,'Macierz B');
wypisz(C,'Macierz C= A +B');
czekaj;
end.
wersja 3.
program procedury_z_parametami_przekazywanymi_przez_zmienne;
uses Crt;
const maxW=10;
maxK=5;
type macierz=Array[1..maxW,1..maxK] of Real;
var A,B,C:Macierz;
W,K:Word;
procedure czekaj; { procedura bez parametrow formalnych }
var znak:Char;
begin
Write(' ... nacisnij dowolny klawisz ...');
znak:=Readkey;
stos dla zmiennych lokalnych
segment danych
adres
blok kodu programu lub modułu
zmienna globalna
procedura- 10 -
end;
procedure czytaj_WK(var N_wierszy,N_kolumn:Word);
{parametry N_wierszy i N_kolumn przekazywane sa przez zmienne }
begin
Repeat
Write('Podaj liczbe wierszy (W<=',maxW,') W = ');
Readln(N_wierszy);
Until N_wierszy<=maxW;
Repeat
Write('Podaj liczbe kolumn (K<=',maxK,') K = ');
Readln(N_kolumn);
Until N_kolumn<=maxK;
end;
procedure czytaj_macierz(var tablica:macierz;
oznaczenie:String);
{ parametr tablica jest przekazywany przez zmienna,
parametr oznaczenie - przez wartośc }
var i,j:Word;
begin
Writeln('Wprowadz elementy macierzy ',oznaczenie);
for i:=1 to W do
for j:=1 to K do
begin
Write(oznaczenie,'[',i:2,',',j:2,'] = ');
Readln(tablica[i,j]);
end;
end;
procedure dodaj(X,Y:Macierz;var Z:Macierz);
{ parametry X,Y przekazywane sa przez wartości,
parametr Z - przez zmienna }
var i,j:Word;
begin
for i:=1 to W do
for j:=1 to K do Z[i,j]:=X[i,j]+Y[i,j];
end;
procedure wypisz(tablica:macierz;opis:String);
{ parametry przekazywane sa przez wartości }
var i,j:Word;
begin
Writeln(opis);
for i:=1 to W do
begin
for j:=1 to K do Write(tablica[i,j]:10:2);
Writeln;
end;
end;
begin
czytaj_WK(W,K);
czytaj_macierz(A,'A');
czytaj_macierz(B,'B');
dodaj(A,B,C);
wypisz(A,'Macierz A');
wypisz(B,'Macierz B');
wypisz(C,'Macierz C= A +B');
czekaj;
end.
Przykład 2
Zadanie polega na napisaniu programu rozwiązującego równanie kwadratowe.
Problem ten można rozwiązać następująco:
Wersja 1.
program funkcje_bez_parametrow_formalnych;
uses Crt;
var a,b,c,delta:Real;
x1,x2:Real;
procedure czekaj;
var znak:Char;
begin
Write(' ... nacisnij dowolny klawisz ...');
znak:=Readkey;
end;
procedure dane;
begin
Writeln('Wprowadz parametry rownania kwadratowego');
Write('a = '); Readln(a);
Write('b = '); Readln(b);
Write('c = '); Readln(c);
end;
procedure sprawdz;
begin
if delta < 0 then
begin
Writeln(' Brak pierwiastkow rzeczywistych ');
czekaj;
halt;
end;
if a = 0 then
begin
Writeln(' To nie jest rownanie kwadratowe');;
czekaj;
halt;
end;
end;
function wartosc_delta:Real;
begin
wartosc_delta:=b*b-4*a*c;
Writeln('delta = ',(b*b-4*a*c):10:2);
end;
function pierwiastek_x1:Real;
begin
pierwiastek_x1:=-b-sqrt(delta)/(2*a);
end;
function pierwiastek_x2:Real;
begin
pierwiastek_x2:=-b+sqrt(delta)/(2*a);
end;
begin
dane;
delta:=wartosc_delta;
sprawdz;
x1:=pierwiastek_x1;
x2:=pierwiastek_x2;
Writeln(' x1 = ',x1:10:2);
Writeln(' x2 = ',x2:10:2);
czekaj;
end.
wersja 2.
program funkcje_a_parametrami_przekazywanymi_przez_wartosc;
uses Crt;
var a,b,c,delta:Real;
x1,x2:Real;
procedure czekaj;
var znak:Char;
begin
Write(' ... nacisnij dowolny klawisz ...');
znak:=Readkey;
end;
procedure dane;
begin
Writeln('Wprowadz parametry rownania kwadratowego');
Write('a = '); Readln(a);
Write('b = '); Readln(b);
Write('c = '); Readln(c);
end;
procedure sprawdz;
begin
if delta < 0 then
begin
Writeln(' Brak pierwiastkow rzeczywistych ');
czekaj;
halt;
end;
if a = 0 then
begin
Writeln(' To nie jest rownanie kwadratowe');;
czekaj;
halt;
end;
end;
function wartosc_delta(a,b,c:Real):Real;
begin
wartosc_delta:=b*b-4*a*c;
Writeln('delta = ',(b*b-4*a*c):10:2);
end;
function pierwiastek(ktory:Byte):Real;
begin
if ktory=1 then pierwiastek:=-b-sqrt(delta)/(2*a)
else pierwiastek:=-b+sqrt(delta)/(2*a)
end;
begin
dane;
delta:=wartosc_delta(a,b,c);
sprawdz;
x1:=pierwiastek(1);
x2:=pierwiastek(2);
Writeln(' x1 = ',x1:10:2);
Writeln(' x2 = ',x2:10:2);
czekaj;
end.
Przekazywanie parametrów przez zmienne nieokreślonego typu
Ten sposób stosuje się przede wszystkim w takich procedurach i funkcjach, które przetwarzają struktury danych o róznych rozmiarach. Parametry nieokreślonego typu nie są zgodne z żadnymi zmiennymi. Aby parametrom tym nadać odpowiednie typy, należy zastosować konstrukcję postaci:
identyfikator_typu(odwołanie_do_zmiennej)
Procedura, której
zadaniem jest wczytanie elementów macierzy kwadratowej różnych stopni.
const N1=5; { stopien macierzy }
N2=10;
type macierz1= Array[1..n1,1..n1] of Real;
macierz2= Array[1..n2, 1..n2] of Real;
{ ... }
var A:macierz1;
B:macierz2;
procedure czytaj_macierz(N:Byte; var tablica; oznaczenie:String);
{ parametr tablica jest przekazywany przez zmienną nieokreślonego typu }
var i,j:Word;
begin
if N>10 then Writeln('Za duzy stopien macierzy')
else
begin
Writeln('Wprowadz elementy macierzy ',oznaczenie);
for i:=1 to N do
for j:=1 to N do
begin
Write(oznaczenie,'[',i:2,',',j:2,'] = ');
case N of
1..5 : Readln(macierz1(tablica)[i,j]);
6..10: Readln(macierz2(tablica)[i,j])
end;
end;
end; { else }
end;
begin
{...}
czytaj_macierz(5,A, 'macierz pierwsza');
czytaj_macierz(9,B, 'macierz druga');
{...}
end.
Przetwarzanie plików (operacje wejścia-wyjścia)
Plik są logicznym odwzorowaniem fizycznych zbiorów. Istnieją trzy
rodzaje plików: • tekstowe,
• zdefiniowane (elementowe),
• niezdefiniowane (amorficzne).
Pliki tekstowe zapisują informacje jako ciąg znaków (kodów ASCII) . Można w nich zapisywać wielkości
różnych typów oraz stosować formatowanie zapisu. Pliki te umożliwiają wyłącznie dostęp sekwencyjny do zawartych w nich danych. Oznacza to, że aby odczytać wartość określonego elementu, należy wcześniej
przeczytać to co jest przed nim.
Pliki zdefiniowane wykorzystują w zapisie reprezentację maszynową. W przypadku pliku zdefiniowanego
możliwy jest zapis i odczyt wielkości wyłącznie jednego typu składowego. Pliki te są plikami o dostępie swobodnym, co oznacza, że w każdym momencie możliwy jest dostęp do dowolnego elementu pliku.
Pliki niezdefiniowane stosuje się w celu dostępu do fizycznych zbiorów danych zgodnie z ich wewnętrznym
formatem lub w przypadku, gdy typ pliku nie jest istotny (np. podczas kasowania pliku z dysku).
*W przetwarzaniu plików wyróżnia się następujące etapy:
• kojarzenie pliku z fizycznym zbiorem danych
• otwarcie pliku
• wykonanie operacji plikowych (przetwarzanie pliku)
• zamknięcie pliku
Dostęp do pliku uzyskuje się za pomocą zmiennej plikowej odpowiedniego typu (zmiennej typu plikowego). Zanim zmienną plikową wykorzysta się do przetwarzania pliku, należy, za pomocą odpowiedniej procedury,
skojarzyć ją z fizycznym zbiorem danych. Procedurą wiążącą nazwę urządzenia z którego będzie wyprowadzany/wprowadzany fizyczny zbiór danych ze zmienną typu plikowego jest procedura
Assign. Po skojarzeniu zmiennej plikowej z fizycznym zbiorem danych można zmienną plikową (plik) otworzyć, czyli przygotować ją dowprowadzania/wyprowadzania poszczególnych elementów pliku. Do otwarcia pliku, w zależności od kierunku przesyłania elementów pliku oraz typu pliku, służą procedury Reset, Rewrite i Append
(tylko pliki tekstowe). Dopiero po otwarciu pliku może być on przetwarzany przez program. Po zakończeniu przetwarzania, plik (zmienna plikowa) powinien być zamknięty za pomocą procedury Close. Istnieją dwie predefiniowane zmienne plikowe typu tekstowego które otwierane są automatycznie po rozpoczęciu wykonywania programu. Są to zmienne przypisane do standardowych urządzeń wejścia (zmienna Input) - wyjścia (zmienna Output).
Do odczytywania danych stosuje się procedurę Read (pliki tekstowe i zdefiniowane) lub Readln (tylko pliki tekstowe). Wprowadzanie nowych elementów do plików umożliwiają procedury Write (pliki tekstowe i zdefiniowane) i Writeln (wyłącznie pliki tekstowe).
Funkcje i procedury obsługi dowolnych plików
• Assign(zmienna_plikowa, nazwa_zbioru_typu_łańcuchowego)
Procedura ta umożliwia skojarzenie zmiennej plikowej z fizycznym zbiorem danych o podanej ścieżce (max 79 znaków) . W momencie wywołania powyższej procedury plik nie może być otwarty. Jeżeli jako drugi parametr podamy pusty łańcuch, zmienna plikowa zostanie skojarzona ze standardowymi urządzeniami wejścia i wyjścia
- klawiaturą i monitorem.
• Rewrite(zmienna_plikowa)
Lub
•Rewrite(zmienna_plikowa,rozmiar)Procedura powoduje utworzenie nowego fizycznego zbioru danych o nazwie skojarzonej wcześniej z podaną zmienną plikową (otwarcie do zapisu). W przypadku gdy zbiór o takiej nazwie już istnieje, zostanie on usunięty a w jego miejscu zostanie utworzony nowy zbiór pusty. Zbiór po otwarciu ustawiany jest w pozycji początkowej. Druga postać wywołania procedury może być stosowana tylko w odniesieniu do plików niezdefiniowanych. W przypadku plików niezdefiniowanych, za pomocą parametru rozmiar (typu Word)
można określić rozmiar tworzonych zapisów zewnętrznego zbioru danych. Pominięcie tego argumentu
(parametru) oznacza przyjęcie rozmiaru domyślnego równego 128 bajtów.
• Reset(zmienna_plikowa)
lub
• Reset(zmienna_plikowa, rozmiar)
Procedura ta służy do otwarcia pliku skojarzonego z już istniejącym zbiorem. (Otwarcie do odczytu). Zbiór po otwarciu ustawiany jest w pozycji początkowej. Druga postać wywołania procedury może być stosowana tylko w odniesieniu do plików niezdefiniowanych.
• Close(zmienna_plikowa);
Procedura zamyka fizyczny zbiÛr danych skojarzony ze zmienną plikową.
• Eof(zmienna_plikowa);
lub
• Eof (gdy wywołanie dotyczy standardowego pliku wejściowego Input).Funkcja ta przyjmuje wartość logiczną TRUE gdy plik znajduje się w pozycji przed ostatnim znakiem zbioru
(znakiem Ctrl-Z) lub gdy zbiór nie zawiera żadnych elementów. W przeciwnym wypadku ma wartość FALSE.
• Erase(zmienna_plikowa)
Procedura usuwa zbiór skojarzony ze zmienną plikową. Plik ten nie może być otwarty.
• Rename(zmienna_plikowa, łańcuch).Procedura umożliwia zmianę nazwy zbioru dyskowego. Zbiorowi skojarzonemu ze zmienną plikową nadawana jest nazwa określona przez łańcuch. Plik nie może być otwarty.
• ChDir(ścieżka)
Procedura umożliwiają zmianę bieżącego katalogu na katalog i/lub napęd określony przez ścieżkę, np.:
ChDir('C:');
ChDir(A:\PROGRAMY');
• GetDir(liczba, łańcuch)-Po wywołaniu tej procedury uzyskamy informacje o bieżącym katalogu w określonym napędzie.
liczba = 0 - napędem jest napęd bieżący
liczba = 1 - napęd A
liczba = 2 - napęd B, itd.
Nazwa bieżącego katalogu (dla napędu określonego liczbą) podstawiana jest pod zmienną łańcuch typu string.
Dla przykładu, po wywołaniu procedury
GetDir(3,katalog);
pod zmienną katalog podstawiana jest nazwa bieżącego katalogu na dysku C:
• MkDir(łańcuch)
Procedura powoduje utworzenie nowego podkatalogu określonego przez łańcuch (ścieżkę nowego
podkatalogu), np.;
MkDir('A:\PASCAL\DANE');
{ utworzenie na dyskietce w napędzie A: w katalogu PASCAL podkatalogu DANE }
• RmDir(ścieżka)
Procedura usuwa pusty podkatalog określony przez ścieżkę.
• IOResult-Jest to bezparametrowa funkcja typu Word podająca, w przypadku wyłączonej kontroli systemowej warunków wejścia wyjścia, status ostatnio wykonanej operacji wejścia-wyjścia. Jeżeli podczas wykonywania operacji wejścia wyjścia nie wystąpi żaden błąd to funkcja przyjmuje wartość 0, w przeciwnym wypadku
zwraca kod błędu.
Funkcje i procedury przetwarzania plików tekstowych
Pliki tekstowe zapisują informacje jako ciąg znaków, kodów ASCII. Dzięki temu można w nich zapisywać wielkości praktycznie dowolnych typów. Ograniczeniem dla plików tekstowych jest sekwencyjny dostęp do
danych. Oznacza to, że aby dostać się do określonego elementu należy przeczytać wszystko co jest przed nim.
• Append(zmienna_plikowa)
Procedura otwiera plik skojarzony ze zmienną plikową i ustawia zbiór na pozycji końcowej (otwarcie do
dopisywania).
• Eoln(zmienna_plikowa);
Lub
• Eoln (gdy wywołanie dotyczy standardowego pliku wejściowego Input)-Funkcja, której wartość logiczna jest TRUE gdy plik znajduje się w pozycji znaku końca wiersza (tj. znaku CR) lub gdy wartością funkcji Eof dla tej samej zmiennej plikowej jest TRUE. W przeciwnym wypadku wartością funkcji jest FALSE.
• Flush(zmienna_plikowa)
Procedura ta powoduje dla pliku tekstowego otwartego wywołaniem procedury Rewrite lub Append
wyzerowanie bufora wejścia. Przez ten bufor wprowadzane są zapisy do zewnętrznego zbioru danych.
•Read(zmienna_plikowa,lista_zmiennych)
lub
•Readln(zmienna_plikowa,lista_zmiennych)
Procedury te służą do czytania elementów z plików. Pierwszym parametrem tych procedur jest odpowiednia zmienna plikowa, po której następują oddzielone przecinkami nazwy czytanych zmiennych. Po każdorazowym
odczytaniu wartości pojedynczej zmiennej następuje automatyczne przesunięcie wskaźnika do początku następnego elementu. W przypadku procedury Readln wskaźnik przesuwa się do początku następnego wiersza.
•Write(zmienna_plikowa,lista_argumentów)
lub
•Writeln(zmienna_plikowa,lista_argumentów)
Procedury powyższe umożliwają wprowadzanie elementów do plików. Podobnie jak w przypadku czytania,pierwszym parametrem tych procedur jest identyfikator odpowiedniej zmiennej plikowej, odpowiadającej otwartemu uprzednio plikowi. Wywołanie procedur powoduje zapisanie do fizycznego zbioru odpowiednich
wielkości. Po każdorazowym zapisaniu wartości pojedynczej zmiennej następuje automatyczne przesunięcie wskaźnika do początku następnego elementu. W przypadku procedury Writeln wskaźnik przesuwa się do
początku następnego wiersza.
• SeekEof (zmienna_plikowa);
lub
• SeekEof
Funkcja ta daje takie same wyniki jak funkcja Eof, z tym że ignoruje najbliższe spacje, znaki tabulacji oraz znaki CR i LF.
• SeekEoln (zmienna_plikowa);
lub
• SeekEof-Funkcja ta daje takie same wyniki jak funkcja Eoln, z tym że ignoruje najbliższe spacje, znaki tabulacji oraz
znaki CR i LF.
• SetTextBuf(zmienna_plikowa, bufor)
lub
• SetTextBuf(zmienna_plikowa, bufor, rozmiar)-Procedura ta przypisuje bufor wejścia wyjścia do danego pliku tekstowego. Bufor jest w tym przypadku-dowolna zmienną. Zwiększając rozmiar bufora można uzyskać np. szybszy odczyt danych ze zbioru.
Funkcje i procedury działające wyłącznie na plikach nietekstowych
• FileSize(zmienna_plikowa)
Wartością funkcji jest rozmiar (LongInt) wyspecyfikowanego pliku
• FilePos(zmienna_plikowa)
Wartością funkcji jest liczba całkowita typu LongInt, podająca aktualną pozycje pliku skojarzonego ze zmienną
plikową .Wartość funkcji jest równa 0 jeżeli plik znajduje się w pozycji początkowej, natomiast gdy plik
znajduje się w pozycji końcowej wartość ta jest równa wartości funkcji FileSize.
• Seek(zmienna_plikowa, pozycja)
Procedura ta umożliwia przesunięcie aktualnego położenia pliku do elementu o podanej liczbie porządkowej, określonego parametrem pozycja typu LongInt.
• Truncate(zmienna_plikowa)
Procedura usuwa z pliku skojarzonego ze zmienną plikową wszystkie elementy począwszy od aktualnej pozycji do końca pliku.
PRZYKŁADY
Przykład 1
Utwórz plik tekstowy skojarzony ze zbiorem dane.txt i zapisz do niego wartości zmiennych x, y, z.
var dane : Text
{ ... }
Assign (dane, 'dane.txt'); { skojarzenie zmiennej plikowej dane ze zbiorem Ñdane.txtî }
Rewrite (dane); { otwarcie pliku do zapisu }
Write (dane, x, y, z); { zapisanie wartości zmiennych x, y, z }
Close (dane); { zamknięcie pliku }
{ ... }
Przykład 2
Do istniejącego pliku tekstowego Ñdane.txtî dopisz wartości zmiennych x, y, z
var dane:Text
{ ... }
Assign (dane, 'dane.txt'); { skojarzenie zmiennej plikowej dane ze zbiorem Ñdane.txtî }
Append (dane); { otwarcie pliku do Ñdopisywaniaî }
Write (dane, x, y, z); { zapisanie wartości zmiennych x, y, z }
Close (dane); { zamknięcie pliku }
{ ... }
Przykład 3
Do pliku zdefiniowanego (plik : file of Byte) dane.dat, zapisz 10 przypadkowych liczb całkowitych.
var plik : file of Byte;
{ ... }
Assign (plik, 'dane.dat');
Rewrite(plik);
Randomize;
for i:=1 to 10 do
begin
x:=Random(255);
Write(plik,x);
end;
Close(plik);
{ ... }
Przykład 4
Z pliku zdefiniowanego (plik : file of Byte) dane.dat, odczytaj n-ty element.
var plik:file of Byte;
{ ... }
Write('Podaj numer kolejny elementu :');
Readln(numer);
Assign (plik, 'dane.dat');
Reset(plik);
if numer <= FileSize(plik) then { sprawdzamy, czy istnieje element }
begin
Seek (plik, numer-1); { numer-1, ponieważ pierwszy element ma numer 0 }
Read (plik, liczba);
end else Write('Brak elementu ',numer);
Close (plik);
{ ... }
Przykład 5
Na końcu pliku zdefiniowanego Ñdane.datî dopisz jeden element.
var plik:file of Byte;
x : Byte;
{ ... }
Assign (plik, 'dane.dat');
Reset (plik);
Seek (plik, FileSize(plik)); { porÛwnaj z procedurą Append }
Write (plik, x);
Close (plik);
{ ... }
Przykład 6
Odczytaj z pliku zdefiniowanego Ñdane.datî wszystkie elementy i wypisz je na ekranie.
var plik : file of Byte;
x:Byte;
{ ... }
Assign (plik, 'dane.dat' );
Reset (plik);
while not Eof(plik) do { dopoki nie ma końca zbioru }
begin
Read (plik, x);
Writeln (x)
end;
Close (plik);
{ ... }
Przykład 7
Przykład programu korzystającego z plików tekstowych.
program pliki_tekstowe_macierze;
const max_W = 10;
max_K = 10;
var f : Text;
opis : String;
N_wierszy,N_kolumn : Word;
macierz : Array [1..max_W,1..max_K] of Real;
i,j : Integer;
procedure czytaj;
begin
Assign(f,'dane.txt');
{ Skojarzenie zmiennej plikowej f z fizycznym zbiorem danych dane.txt }
Reset(f);
{ Otwarcie zmiennej plikowej (pliku dane.txt) do odczytu }
Readln(f,opis);
{ Wczytanie 1-ego wiersza pliku dane.txt i przejście do początku następnego wiersza }
Read(f,N_wierszy,N_kolumn);
{ Wczytanie liczby wierszy i liczby kolumn macierzy }
Readln(f);
{ Przejście do początku następnego wiersza pliku }
for i:=1 to N_wierszy do
begin
for j:=1 to N_kolumn do Read(f,macierz[i,j]);
{ Wczytanie elementÛw jednego wiersza macierzy }
Readln(f);
{ Przejście do początku wiersza następnego }
end;
Close(f);
{ Zamknięcie zmiennej plikowej f (pliku dane.txt) }
end; { procedury czytaj }
procedure wypisz_na_ekran;
begin
for i:=1 to N_wierszy do
begin
for j:=1 to N_kolumn do Write(macierz[i,j]:6:2);
{ Wypisanie jednego wiersza macierzy na ekranie monitora}
Writeln;
{ Przejście do początku wiersza następnego }
end;
end; { wypisz_na_ekran}
procedure zapisz_do_pliku;
begin
Assign(f,'wyniki.txt');
{ Skojarzenie zmiennej plikowej f z fizycznym zbiorem danych wyniki.txt }
Rewrite(f);
{ Otwarcie zmiennej plikowej f (pliku wyniki.txt) do zapisu }
Writeln(f,opis+' pomnozona przez 2');
{ Zapis 1-ego wiersza w pliku wyniki.txt i przejście do początku następ. wiersza }
Write(f,N_wierszy,' ',N_kolumn);
{ Zapisanie liczby wierszy i liczby kolumn macierzy }
Writeln(f);
{ Przejście do początku następnego wiersza }
for i:=1 to N_wierszy do
begin
for j:=1 to N_kolumn do Write(f,2*macierz[i,j]:10:2);
{ Zapisanie jednego wiersza macierzy }
Writeln(f);
{ Przejście do wiersza następnego }
end;
Close(f);
{ Zamknięcie zmiennej plikowej f (pliku wyniki.txt) }
end; {wypisz_do_pliku}
procedure dopisz_do_pliku;
begin
Assign(f,'wyniki.txt');
{ Skojarzenie zmiennej plikowej f z fizycznym zbiorem danych wyniki.txt }
Append(f);
{ Otwarcie zmiennej plikowej f (pliku wyniki.txt) do dopisywania }
Writeln(f,opis);
{ Dopisanie wiersza do pliku wyniki.txt i przejście do początku następnego wiersza }
Write(f,N_wierszy,' ',N_kolumn);
{ Zapisanie liczby wierszy i liczby kolumn macierzy }
Writeln(f);
{ Przejście do początku następnego wiersza }
for i:=1 to N_wierszy do
begin
for j:=1 to N_kolumn do Write(f,macierz[i,j]:10:2);
{ Zapisanie jednego wiersza macierzy }
Writeln(f);
{ Przejście do wiersza następnego }
end;
Close(f);
{ Zamknięcie zmiennej plikowej f (pliku wyniki.txt) }
end; { dopisz_do_pliku }
begin { programu }
czytaj; { wywołanie procedury czytaj }
wypisz_na_ekran; { wywołanie procedury wypisz_na_ekran }
zapisz_do_pliku; { wywołanie procedury zapisz_do_plikuj }
dopisz_do_pliku; { wywołanie procedury dopisz_do_pliku }
end. { programu }
Zawartość pliku dane.txt (plik ten znajduje się w bieżącym katalogu) :
Macierz A
2 3
1.34 1.56 -0.45
0.34 -3.45 1.22
Zawartość pliku wyniki.txt po wywołaniu procedury zapisz_do_pliku
Macierz A pomnozona przez 2
2 3
2.68 3.12 -0.90
0.68 -6.90 2.44
Zawartość pliku wyniki.txt po wywołaniu procedury dopisz_do_pliku
Macierz A pomnozona przez 2
2 3
2.68 3.12 -0.90
0.68 -6.90 2.44
Macierz A
2 3
1.34 1.56 -0.45
0.34 -3.45 1.22
Przykład 8
Przykład programu przetwarzającego pliki zdefiniowane.
program pliki_zdefiniowane;
uses Crt;
type punkty = record
Oznaczenie : String[10];
X,Y,Z : Real;
end;
var wsp : punkty;
f : file of punkty;
N_pkt : Integer;
opis : String;
i,j : Integer;
procedure czekaj;
var znak:Char;
begin
Writeln; Write('Nacisnij dowolny klawisz ...'); znak:=Readkey; Writeln;
end;
procedure wprowadz_zapisz;
begin
ClrScr;
Write(' Podaj liczbe wprowadzanych punktow : ');
Readln(N_pkt);
Writeln('---------------------------------------------------');
Assign(f,'dane.wsp')
Rewrite(f);
for i:=1 to N_pkt do
begin
Writeln('Numer kolejny punktu : ',i:3);
Write('Podaj oznaczenie punktu (maksymalnie 10 znakow) : ');
Readln(wsp.oznaczenie);
Write('Wspolrzedna X = '); Readln(wsp.X);
Write('Wspolrzedna Y = '); Readln(wsp.Y);
Write('Wspolrzedna Z = '); Readln(wsp.Z);
Writeln('---------------------------------------------------');
Write(f,wsp);
end;
Close(f);
end;
procedure czytaj_wypisz;
var k:Integer;
begin
ClrScr;
Assign(f,'dane.wsp');
Reset(f);
Writeln(' Wykaz wspolrzednych punktow');
Writeln;
Writeln(' Lp Oznaczenie X Y Z');
Writeln;
k:=0;
while not Eof(f) do { Eof - patrz Funkcje i procedury obsługi zbiorÛw }
begin
k:=k+1;
Read(f,wsp);
Write(k:5);
Write(wsp.oznaczenie:15);
Writeln(wsp.X:15:3,wsp.Y:12:3,wsp.Z:12:3);
end;
Close(f);
czekaj;
end;
procedure czytaj_wypisz_jeden_punkt;
var Lp : Integer;
Blad : Word;
begin
ClrScr;
Write('Podaj nr kolejny punktu : '); Readln(Lp);
ClrScr;
Assign(f,'dane.wsp');
Reset(f);
Seek(f,Lp-1);
{Seek - standardowa procedura modułu system,
patrz: Funkcje i procedury obsługi zbiorÛw }
{$I-}
{ lokalna, przełącznikowa dyrektywa kompilatora, patrz: Dyrektywy kompilatora }
Read(f,wsp);
{$I+}
{ lokalna, przełącznikowa dyrektywa kompilatora, patrz: Dyrektywy kompilatora }
Blad:=IOResult;
{ IOResult - bezparametrowa funkcja modułu system,
patrz: Funkcje i procedury obsługi zbiorÛw }
if Blad<>0 then
begin
Writeln('Blad odczytu z dysku');
halt;
end;
Writeln(' Punkt nr kolejny : ',Lp);
Writeln;
Writeln(' Oznaczenie X Y Z');
Writeln;
Write(wsp.oznaczenie:15);
Writeln(wsp.X:15:3,wsp.Y:12:3,wsp.Z:12:3);
Close(f);
czekaj;
end;
begin
wprowadz_zapisz;
czytaj_wypisz;
czytaj_wypisz_jeden_punkt;
end.