Wykłady z Podstaw
Programowania
Język Turbo Pascal 7.0
Politechnika Białostocka
Wydział Informatyki
Jarosław S. Walijewski
Języki programowania -Pascal Strona 2
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Wykłady Podstaw Programowania
1Literatura:
2Historia
2.1Języki Programowania.
3Podstawowe pojęcia
3.1Budowa programu
3.2SÅ‚owa kluczowe
3.3Podstawowe typy danych
3.3.1Typy całkowite
3.3.2Typy rzeczywiste
3.3.3Znaki i łańcuchy znaków
3.3.4Deklaracja stałych i zmiennych typów znakowych
3.4Elementy programu
3.4.1Struktura programu
3.4.2Komentarze
3.4.3Instrukcja przypisania
4Wyrażenia
4.1Wyrażenia arytmetyczne
5Operatory
5.0.2Operatory arytmetyczne
5.0.3Priorytet operatorów
5.0.4Przykłady
5.1Wyrażenia logiczne
5.2Operatory relacji
5.3Operatory logiczne
5.3.1Priorytet operatorów
6 Instrukcje
6.1Instrukcje wejścia /wyjścia
(Input/ Output )
6.1.1Wyjście - procedury Write , Writeln
6.1.2Wejście - procedury Read , ReadLn
6.2 Instrukcje strukturalne
6.2.1 Instrukcje złożone
6.2.2Instrukcja warunkowa
6.2.3Instrukcja wyboru CASE
6.3Instrukcje iteracyjne
6.3.1Instrukcja FOR
Języki programowania -Pascal Strona 3
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
6.3.4Instrukcja WHILE
6.3.5Instrukcja Repeat
6.4Inne instrukcje
6.4.1Instrukcja kodu
6.4.2Instrukcja asemblerowa
6.4.3Instrukcja skoku
6.4.4Instrukcje Break i Continue
7Typy danych c.d.
7.1Typy wprowadzone wcześciej
7.2Typ wyliczeniowy
7.3Typ okrojony
7.4Typ zbiorowy
7.5Typ tablicowy
7.5.1String
7.5.2Tablice wielowymiarowe
8Podprogramy
8.1Istota programowania proceduralnego
8.1.1Pojęcie procedury
8.1.2Pojecie funkcji
8.1.3Deklaracje, definicja i wywołanie podprogramów
8.1.4Parametry podprogramów
8.1.5Inne przykładowe funkcje
8.1.6Zalety programowanie z wykorzystaniem podprogramów
8.1.7Rekurencja
9Rekordy i tablice rekordów
9.1Istota typu rekordowego
9.2Rekordy z częścią stałą
9.2.1Instrukcja wiążąca WITH
9.2.2Rekord z wariantami
10Operacje wejścia  wyjścia
10.1Podstawowe operacje na plikach
10.2Pliki tekstowe
10.2.1Plik tekstowy a plik file of char
10.3Pliki elementowe
10.4Pliki amorficzne
10.5Funkcje i procedury operujÄ…ce na plikach
11Biblioteki Turbo Pascala
11.1Moduł Crt
Języki programowania -Pascal Strona 4
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
11.1.1 STALE
11.1.2 ZMIENNE
11.1.3 FUNKCJE I PROCEDURY
11.2Moduł System
11.3Moduł Dos
11.4Moduł tworzone przez użytkownika
12Dynamiczne struktury danych
12.0.1Pojęcie wskaz
nika
12.1Tablica wskazników
12.2Stos
12.2.1Struktura stosu
12.2.3Na stos
12.2.4Ze stosu
12.2.5Zastosowanie stosu
12.3Listy 1 i 2 kierunkowe
12.3.1Struktura listy 1 kierunkowej
12.3.2Podstawowe operacje na liście
12.3.3Struktura listy 2 kierunkowej
12.3.4Dodawanie do listy
12.3.5Zastosowanie list
12.4Drzewa binarne
12.4.1Strukrura danych
12.4.2Tworzenie Drzewa
12.4.3Szukanie elementu
12.4.4Usuniecie liścia i węzła
12.4.5Równoważenie Drzewa
13Grafika w Turbo Pascalu
13.1Programowanie w trybie graficznym
13.1.1Wprowadzenie do pracy w trybie graficznym
13.2Narzędzia graficzne w Turbo Pascalu
13.2.1Moduł Graph
Języki programowania -Pascal Strona 5
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
1 Literatura:
1. N. Wirth  Algorytmy + struktury danych = Programy , WNT
2. A. Marciniak  Turbo Pascal 7.0 WNT
3. W. Porębski  Pascal-Wprowadzenie do programowania , Help
4. Sam Abolrous  Pascal Podstawy programowania , Mikom
5. B. Jankowski  Programowanie w praktyce , Mikom
6. B Kernighan, P. Plauger  Narzędzia programistyczne w Pascalu ,
WNT
7. Borland TP7  User s Guide
8. Borland TP7  Language Guide
9. Borland TP7  Programmer s Reference
10. Skrypt wykładów http://aragorn.pb.bialystok.pl/~walijewski
Języki programowania -Pascal Strona 6
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
2 Historia
üð 1971 Niklaus Wirth, profesor informatyki Politechniki w
Zurychu, opublikował pierwszy artykuł o Pascalu "The programming
language Pascal"
o W zamierzeniu Wirth a Pascal miał służyć przede wszystkim
do nauki programowania strukturalnego, tj. programowania
dużych systemów tzw. "z góry - na dół", czyli określania
dużych elementów poprzez elementy niższego rzędu, aż do
końcowych elementów programowych realizujących określone
funkcje.
üð 1973 Kathlen Jensen "Pascal, User Manual and Report" - pierwszy
podręcznik języka
üð 1983 Turbo Pascal 1.0 amerykaÅ„skiej firmy Borland International
(obecnie Inprise)
üð Turbo Pascal 3.0  zapoczÄ…tkowaÅ‚a sukces TP
üð Turbo Pascal 4.0  nowe zintegrowane Å›rodowisko,
implementacja modułów.
üð 1988 Turbo Pascal 5.0
üð 1989 Turbo Pascal 5.5 - Pierwsza implementacje
Programowania obiektowego w TP
üð Turbo Pascal 6.0  ZawieraÅ‚a nowÄ… bibliotekÄ™ Turbo Vision
üð 1992 Borland Pascal 7.0 i Turbo Pascal 7.0
Pakiety te zawierajÄ… m.in. zintegrowane, interakcyjne systemy
programowania, które składają się z kompilatorów języka,
złączonych z nimi ekranowych, wielookienkowych edytorów tekstów
i wbudowanych w systemy programów lokalizacji i usuwania usterek
(ang. debugger) oraz przeglądania powiązanych elementów
programów (ang. browser).
Języki programowania -Pascal Strona 7
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
2.1 Języki Programowania.
W pamięci program jest zapisany jako Kod Maszynowy, czyli instrukcje
dla konkretnego procesora. Są one pamiętane jako liczby w systemie
binarnym (zerojedynkowym).
Powstał więc Asembler - język pierwszej generacji. Jego rozkazy
odpowiadają bezpośrednio instrukcjom procesora, jednak zapisywane są w
bardziej zrozumiałej formie.
Druga generacja to języki nie mające już tak bliskiego związku z
procesorem, ale nadal podobnie jak asembler stanowiÄ…ce jeden ciÄ…g
instrukcji. Są to tak zwane języki interpretowane. Przykładem takiego
języka może być ogólnie znany Basic. Jedna instrukcja języka drugiej
generacji, może być tłumaczona na kilka, kilkadziesiąt a czasem więcej
instrukcji procesora.
Języki kolejnej generacji, np. Pascal, rozwijają koncepcję programowania
o możliwość podzielenia programu na moduły wykonujące różne operacje
wchodzące w jego skład. Każda taka część stanowi pod pewnym
względem zamkniętą całość i jej "wnętrze" nie jest dostępne.
Wykorzystanie jej polega na przekazaniu parametrów (i ewentualnym
odebraniu wyniku). Typowymi modułami są funkcje i procedury.
Kolejny to języki Zorientowane Obiektowo (OO). Przykład to C++,
Delphi. Chociaż w Pascalu też można pisać programy OO.
Powstały również języki czwartej generacji. Są to języki umożliwiające
pisanie programów tzw. bardzo wysokiego poziomu, niezależne od
sprzętu, a nawet systemu operacyjnego. Przykład to języki dostępu do baz
danych.
Języki programowania -Pascal Strona 8
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
3 Podstawowe pojęcia
3.1 Budowa programu
Program pascalowy buduje się z elementarnych jednostek języka zwanych
symbolami. Symbol składa się ze znaku lub ciągu znaków alfabetu .
Alfabet zawiera :
üð duże i maÅ‚e litery alfabetu Å‚aciÅ„skiego i znak _
üð cyfry od 0 do 9
üð symbole specjalne ( jednoznakowe)
üð+ - * / = < > { }[ ] ( ) . : ; ^
üð Ze znaków tworzy siÄ™ symbole specjalne ( wieloznakowe)
üð<> <= >= := ..
üðspacja
üð i sÅ‚owa kluczowe ( zastrzeżone)
W taki sam sposób tworzymy identyfikatory stałych, zmiennych, typów,
podprogramów etc. Symbole specjalne, podobnie jak znak spacji są
separatorami jednostek leksykalnych.
3.2 SÅ‚owa kluczowe
Słowa kluczowe są to spójne ciągi liter tworzące zarezerwowane słowa
angielskie o ustalonym znaczeniu. Używa się ich w z góry określony
sposób. Są zastrzeżone, tzn. nie mogą być zmieniane przez programistę.
Ich nazw nie można w programie użyć jako identyfikatora do jakiegoś
elementu. Poniżej ich lista:
And Array Asm Begin Case
Const Constructor Destructor Div Do
Downto Else End File For
Function Goto If Implementation In
Inherited Inline Interface Label Mod
Nil Not Object Of Or
Packed Procedure Program Record Repeat
Set Shl Shr String Then
To Type Unit Until Uses
Var While With Xor
Oprócz słów kluczowych w Turbo Pascalu występują Dyrektywy języka.
W odróżnieniu od słów kluczowych, nie są one zastrzeżone - podane
Języki programowania -Pascal Strona 9
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
wyrazy mogą więc być identyfikatorami zdefiniowanymi przez
programistÄ™, co jednak nie jest zalecane. Pewnym wyjÄ…tkiem sÄ… dyrektywy
private i public, które w obiektach, ale tylko w nich, są słowami
zastrzeżonymi. Dyrektywą jest każdy z następujących wyrazów :
Absolute Far Near Public
Assembler Forward Private Virtual
External Interrupt
Przykłady identyfikatorów
Ala ala Do
Ola1_1 Ola-1
Koniec PoczÄ…tek
Liczba Integer String
Pascal Far Typ danych
_For Private 23cia
3.3 Podstawowe typy danych
Język Pascal pozwala na abstrahowanie od reprezentacji danych w pamięci
komputera.
Osiągnięto to poprzez wprowadzenie pojęcia typu. Przyjęto założenie, że
każda zmienna, wyrażenie lub funkcja jest pewnego typu.
Typ ten określa
üð zbiór wartoÅ›ci staÅ‚ej, zmiennej etc.
üð zbiór operacji jakie można wykonać na obiektach
3.3.1 Typy całkowite
TYPY CAA
KOWITE - są to wartości liczbowe, które mieszczą się w
podanych zakresach, im większy zakres to automatycznie zwiększa się
zapotrzebowanie liczby na pamięć:
SHORTINT (-128..127) 1 bajt
INTEGER (-32768..32767) 2 bajty
LONGINT (-2147483648..2147483647) 4 bajty
BYTE (0..255) 1 bajt
WORD (0..65535) 2 bajty
3.3.2 Typy rzeczywiste
Nazwa Zakres Długość Dokładność (cyfr)
real 2.9e-39 ÷ 1.7e38 6 bajtów 11 ÷ 12
single 1.5e-45 ÷ 4.0e38 4 bajty 7÷ 8
Języki programowania -Pascal Strona 10
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
double 5.0e-324 ÷ 1.7e308 8 bajtów 15 ÷ 16
extended 3.4e-4932 ÷ 1.1e4932 10 bajtów 19 ÷ 20
comp -9.2e18÷ 9.2e18 8 bajtów 19 ÷ 20
Użycie typów Comp lub Extended wymaga deklaracji wykorzystywania
w przez program koprocesora( "Must be in 8087 mode to compile this."
{$N+} ) W menu OPTIONS/COMPILER w dziale Numeric processing
należy wybrać opcję 8087/80287
Opcja {$E+} umożliwia uruchomienie programową emulację koprocesora,
w przypadku braku jednostki sprzętowej.
3.3.3 Znaki i łańcuchy znaków
Zbiór znaków (typ char) został zdefiniowany przez tablicę kodów ASCII.
3.3.3.1 Znaki sterujÄ…ce ( kontrolne )
Znaki o kodach 0 - 31 , 127 noszą nazwę znaków sterujących . Ich
graficzna reprezentacja nie zawsze będzie wyświetlana . Są to znaki
użyteczne przy sterowaniu komputerem .
Np
program bell;
begin
write(#7); write(char(7));
end.
Wykonanie programu powoduje wydanie dz
więku dzwonka (ang. Bell ).
3.3.3.2 Znaki podstawowego i rozszerzonego kodu ASCII
SÄ… to znaki odpowiadajÄ…ce kodom 32 ( spacja) - 126 ( ~). MieszczÄ… siÄ™ tu
znaki alfabetu Pascala ( małe i wielkie litery łacińskie , liczby ,znaki
operatorów itp. ).
Znaki o kodach 128- 225 sÄ… to znaki tzw. rozszerzonego kodu ASCII .
Znaki te mogą być zmieniane , w celu uzyskania symboli specyficznych
dla danego języka np. 

Standardowo znajdują się tam znaki do kreślenia ramek , kilka znaków
używanych w transkrypcji i inne .
Dostęp do tych znaków może być zrealizowany na trzy sposoby
1. #Nr_Znaku np. #65
2. wykorzystanie funkcji char
char ( Nr_Znaku ) ; np. char (65)
3. wypisanie symbolu znaku w apostrofach np. 'A'
Języki programowania -Pascal Strona 11
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
3.3.3.3 Typ łańcuchowy -String
Umieszczenie pomiędzy apostrofami ciągu znaków (łańcucha) jest
również dopuszczalne np.
Program string1;
begin
write('PASCAL);
end .
Ciąg znaków jest związany z typem string; Oczywiste jest , że typ char
jest w nim zawarty jako ciągi długości 1.
Program string_char;
begin
write('P','A','S','C','A','L');
end .
Inny specjalny napis to tzw. string pusty '' (apostrof apostrof)
3.3.4 Deklaracja stałych i zmiennych typów
znakowych
Stałe
const Litera = 'A';
const Imie = ' Anna';
Zmienne
var c : char;
var S : String;
var s10: String[10];
Zmienne z wartością początkową
(dotyczy TURBO PASCAL i BORLAND PASCAL )
{1}
constc : char = 'A' ;
s1 : String[1] = 'Q'; {2}
S : String= 'A'; {3}
s10 : String[10]= 'Kot'; {4}
St : String = 'To jest napis !';{5}
Jakie są podobieństwa i różnice pomiędzy deklaracjami {1},{2}i{3}?
3.4 Elementy programu
3.4.1 Struktura programu
Program Nazwa; {nagłówek programu}
Uses ...; {deklaracje użycia modułów}
Języki programowania -Pascal Strona 12
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Const ... {deklaracje stałych globalnych}
Type ... {deklaracje typów}
Var ... {deklaracje zmiennych globalnych}
Procedure Nazwa(paramerty); {nagłówek
podprogramu - procedury}
Var ... {deklaracja zmiennych lokalnych}
Begin
... {instrukcje podprogramu}
End;
Function Nazwa(paramerty):Typ_wyniku;
{nagłówek funkcji}
Var ... {deklaracja zmiennych lokalnych }
Begin
... {instrukcje podprogramu}
End;
BEGIN
... {instrukcje bloku głównego programu}
END. { zakończenie bloku głównego kropką}
Najkrótszy poprawny program w TP to:
Program Nazwa;
Begin
End.
Języki programowania -Pascal Strona 13
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
3.4.2 Komentarze
Każdy program po pewnym czasie może stać się nawet trudy do
zrozumienia nawet dla autora . Można jednak ten proces osłabić poprzez
odpowiednie pisanie programów.
W tym celu należy opisywać wszystkie bardziej złożone fragmenty
programów, a także używać identyfikatorów, których nazwy przybliżają
ich zastosowanie.
Przykład 1:
(* komentarz *)
var n,m,k : integer;
begin
n:=2;
m:=6;
k:=n*m;
writeln(iloczyn { komentarz } );
{ to
także
jest
komentarz }
end.
Wprawdzie to nie jest komentarz, ale kompilator
potraktuje ten takst jako komentarz.
Przykład 2 :
Program iloczyn;
var czynnik1,czynnik2, { czynniki }
iloczyn : (*wynik mnożenia *)
integer; { typ zniennych }
BEGIN
czynnik1:=2 ; {przypisanie wartości do}
czynnik2:=2 ; { czynników }
iloczyn:=czynnik1 * czynnik1;
{wyliczenie wyniku mnożenia}
writeln('Wynik mnożenia ' , czynnik1,' przez
',czynnik2,' wynosi : ',iloczyn ) ;
END.
Języki programowania -Pascal Strona 14
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
3.4.3 Instrukcja przypisania
Nadawanie wartości następuje bardzo często za pośrednictwem instrukcji
przypisania, która ma ogólną postać :
zmienna := wyrażenie ;
Operator  :=  nazywa siÄ™ operatorem przypisania , symbol zmienna
oznacza tu identyfikator; wyrażenie musi być typu konwertowanego do
typu zmiennej. W wersji najprostszej:
zmienna := stała ;
liczba := 10 ;
czytamy : zmiennej liczba przypisz wartość 10 ;
Program Instr_przypisania_1 ;
var liczba :integer ;
BEGIN
liczba :=1;
writeln(liczba);
liczba :=100;
writeln(liczba);
liczba := -237;
writeln(liczba);
END.
{wynik wykonania programu
1
100
-237 }
Istnieje również inny schemat instrukcji przypisania mianowicie
zmienna1 := zmienna2 ;
Jednakże ta postać dopuszczalna jest gdy zajdzie jedno z:
üð typy zmiennych sÄ… zgodne
üð zmienna zmienna2 jest typu konwertowanego typu zmiennej
zmienna1
o typ real (zmienna1) i typ Integer (zmienna1)
Języki programowania -Pascal Strona 15
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Przykład
var a,b :integer;
begin
a:=1;
b:=a;
writeln(c);
writeln(b);
end .
Zmienne były tego samego typu .
Przykład
var s : string ;
const c : char = 'Z';
bagin
s := c ;
writeln(c);
writeln(s);
end .
zmienne miały różne typy
Program Instr_przypisania_2 ;
var liczba : integer ,
litera : char;
BEGIN
liczba := 33; {wynik wykonania
programu }
litera := char (liczba) { ! }
writeln(litera);
END.
Języki programowania -Pascal Strona 16
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Program const_var;
const
c : char='A';
s1 : string[1]='Q';
s : string='A';
s10: string[10]='kot';
st : string='To jest napis';
begin
writeln('******************');
writeln('s1 :',s1);
writeln('c :',c);
s1:='kkk';
writeln('s1 :',s1);
c:='u';
writeln('s10 :',s10);
s10:=st;
writeln('s10 :',s10);
writeln('c :',c)
end.
3.4.3.1 Różnice pomiędzy identyfikatorami stałych i
zmiennych
1. wartości stałych są określone przed rozpoczęciem programu natomiast
zmienne otrzymują wartość w trakcie wykonywania programu ;
2. ( TP ) tylko zmienne deklarowane w sekcji CONST majÄ… nadanÄ…
wartość przed rozpoczęciem programu ;
3. wartość identyfikatora stałej nie może ulec zmianie podczas
wykonywania programu , podczas gdy zmienna może przyjmować
różne wartości
W instrukcji przypisania zmienna := stała ;
wartość stałej musi być tego samego typu , co typ zmiennej . Jedynym
wyjątkiem jest instrukcja przypisania zmiennej typu rzeczywistego stałej
typu całkowitego np.
Języki programowania -Pascal Strona 17
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
program Real_int;
var r :real;
begin
r := 100 ;
end.
Które z definicji są poprawnymi definicjami stałych :
(a) CONST Licza = 250 ;
(b) CONST Liczba = 1,2 ;
(c) CONST Znak = 'A' ;
(d) CONST Max = 250 ;min= -150.7;
(e) CONST zakres = 250 ..500;
(f) CONST L : integer = 250 ;
(g) CONST L : real = 250 ;
(h) CONST L : string = 250 ;
(i) CONST L : char = 250 ;
Które ze zmiennych są zadeklarowane poprawnie :
(a) VAR 1a,2a,3a : Real;
(b)VAR a1,a2,a3 : Real;
b1 : char;
a3 : Integer
(c) VAR a :Char ; b Integer ; c : real;
(d) VAR a1;a2;a3 : Real ,
c : char ;
Zadanie
Napiszmy program , który wydrukuje tekst : S = 1+2 + 3+4+5 , a w
następnym wierszu wartość zmiennej S .
Program Komentarz_1;
var S : Integer;
ST : String;
begin
St := ' S = 1+2+3+4+5 ' ;
S := 1+2+3+4+5 ;
writeln(st);
writeln(s);
end.
Języki programowania -Pascal Strona 18
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
4 Wyrażenia
4.1 Wyrażenia arytmetyczne
Wyrażenia arytmetyczne składają się z elementów typów całkowitych lub
rzeczywistych.
Proste wyrażenia arytmetyczne określają operację arytmetyczną
np. 25 + 130, gdzie  25  i  130 to argumenty wyrażenia, a znak  +
operatorem wyrażenia. Po wykonaniu operacji określonej przez operator
otrzymujemy wynik wyrażenia; W naszym przykładzie  155  .
Wartość tego wyniku możemy wydrukować:
np.
writeln(25+130) ;
Wynik ten możemy zapisać do pewnej(odpowiedniej) zmiennej:
np.
var I :Integer;
....
I := 25+130 ;
Ta własność prowadzi nas do następnego schematu instrukcji przypisania:
zmienna := wyrażenie ;
!!!Wartość wyrażenia musi być typu konwertowanego do danej zmiennej!
Niepoprawna będzie więc instrukcja
Var s : string;
I : Byte;
...
s := 10+11;
I := 3.5;
...
I := 257; Byte 0..255
257 = 256+1
Języki programowania -Pascal Strona 19
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
5 Operatory
5.0.1
5.0.2 Operatory arytmetyczne
Operatory są to symbole wiążące argumenty wyrażenia. Jeśli wyrażenie
zawiera różne operatory to wyliczanie wartości przebiega
zgodnie z kolejnością priorytetów.
5.0.2.1 Operatory jednoargumentowe
+ (znak dodatni argumentu)
- (znak ujemny argumentu)
5.0.2.2 Operatory dwuargumentowe
Op Znaczenie Typ argumentów Typ wyniku
+ Dodawanie
Integer Integer jeśli każdy
- Odejmowanie lub argument jest typu
* Mnożenie
Real Integer , wpp Real
/ Dzielenie
Real
MOD Reszta z dzielenia
DIV Część całkowita z Integer Integer
dzielenia
5.0.3 Priorytet operatorów
Operatory + - mają niski priorytet , pozostałe wysoki .
Wyrażenie wykonywane jest od prawej do lewej strony najpierw
wykonywane są operacje o wysokim priorytecie , a następnie o niskim .
5.0.4 Przykłady
Obliczyć wartość i określić typ wyrażenia :
38 + 39 div 6 * 6 - 66 mod 8 =
38 + 6 * 6 - 66 mod 8 =
38 + 36 - 66 mod 8 =
38 + 36 - 2 =
74 - 2 =
72
Wszystkie argumenty były typu Integer, więc wynik też będzie typu
Integer
Języki programowania -Pascal Strona 20
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
W sytuacji gdy nie wystarczy poprzestanie na kolejności operacji
wynikające z priorytetów działań można kolejność wymusić stosując
nawiasy.
3.5 *(16 div 5 ) + 4.5 = 15.0 ( Real )
Argumentami wyrażenia mogą być także zmienne np
var a,b :integer ;
a* 19+ b / 3 ( Real)
5.1 Wyrażenia logiczne
Wyrażeniem logicznym nazywamy wyrażenie dające w wyniku wartość
typu BOOLEAN , czyli jedną z dwóch stałych : True , False
W wyrażeniach logicznych mogą występować operatory relacji i
operatory logiczne
5.2 Operatory relacji
Operat Znaczenie
or
= Równość
< Mniejszość
> Większość
<> Różność
<= mniejszość lub równość
>= większość lub równość
in przynależność do zbioru
NP
Wyrażenie Wartość
65.6 > 65 True
65.6 < 65 False
10 <> 11 True
6 in [0..9] True
Uwaga:
Argumenty operacji relacji muszą być tego samego typu bądz
typów
konwertowanych .
5.3 Operatory logiczne
Argumenty muszą być typu BOOLEAN
Języki programowania -Pascal Strona 21
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Operator Znaczenie Ilość argumentów
NOT negacja 1
AND koniunkcja 2
OR alternatywa 2
XOR róznica symetyczna 2
Wyniki operacji logicznych
not x not y and y x or y x xory
A1 A2
True True False False True True False
True False False True False True True
False True True False False True True
False False True True False False False
5.3.1 Priorytet operatorów
Priorytet Operatory
0 (najwyższy ) wyrażenia w nawiasach
1 NOT
2 * / DIV MOD AND
3 + - OR XOR
4 < <= >= = <>
Języki programowania -Pascal Strona 22
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
6 Instrukcje
Instrukcja pusta.
Instrukcja przypisania .
zmienna := wyrażenie ;
Instrukcja procedury .
Nazwa; lub Nazwa(parametry);
6.1 Instrukcje wejścia /wyjścia
(Input/ Output )
6.1.1 Wyjście - procedury Write , Writeln
Instrukcja procedury write (writeln ) ma ogólną postać :
write (f , p1 , p2 ,..,pn);
writeln (f , p1 , p2 ,..,pn);
gdzie f -oznacza plik dyskowy ( parametr ten może być pominięty wtedy
dane wypisywane sÄ… na konsolÄ™ , czyli ekran monitora)
natomiast każdy z p może występować w postaci
i
p p:m p:m:n
p jest typu prostego lub string ;
m określa szerokość pola w jakim dane będą wypisywane ;
n określa ilość miejsc po przecinku (tylko typy rzeczywiste)
n, m - wyrażenia całkowite
Program Wypisz ;
var l : Byte;
i : Integer;
r : Real;
begin
i:=2;
l:=7;
r:= l / i ;
write (1:4 );
write (l : 4 );
write(r:5:2);
end.
Jaki będzie wynik wykonania programu ?
Co siÄ™ stanie gdy zmienimy instrukcjÄ™ na :
Języki programowania -Pascal Strona 23
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
write(r:1:2);
write(r:4:1);
Procedury write i writeln mogą być wywoływane ze zmienną ilością
parametrów . Ponadto parametry mogą mieć różne typy .
6.1.2 Wejście - procedury Read , ReadLn
Instrukcja procedury read (readln ) ma ogólną postać :
read (f , p1 , p2 ,..,pn);
readln (f , p1 , p2 ,..,pn);
gdzie f majÄ… takie same znaczenie jak w przypadku procedury Write ,
natomiast każde p jest typu całkowitego , rzeczywistego , char lub string ;
i
Przykład 1:
Program Czytaj_1;
var i : Integer;
begin
Read (i);
writeln;
writeln(i);
end.
Efektem wykonania powyższego programu będzie
1. wczytanie z konsoli ( klawiatura ) liczby całkowitej
2. następnie liczba ta zostanie ponownie wyświetlona
- wypisana będzie wartość zmiennej  i 
Przykład 2:
Program Czytaj_2; Program Czytaj_2_b;
var s1,s2 :string; var s1,s2 :string;
begin begin
Readln(s1); Read(s1);
writeln; writeln;
writeln(s1); writeln(s1);
Readln(s2); Read(s2);
writeln; writeln;
writeln(s1,s2); writeln(s1,s2);
end. end.
Jako ćwiczenie na laboratorium pozostawiam sprawdzenie czy istnieją
różnice w wykonaniu tych dwóch wersji programów . Jeśli tak , to co może
tłumaczyć takie różnice .
Języki programowania -Pascal Strona 24
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Procedura Readln może rówineż zawierać większą ilość parametrów -
może też ich wogóle nie być. Taki przypadek będzie bardzo użyteczny w
celu zatrzymania wykonywania programu .
Program Stoped;
begin
...
readln;
end.
6.2 Instrukcje strukturalne
Poznane jak dotąd instrukcje były instrukcjami prostymi - nie zawierały
w swej składni innych instrukcji . Natomiast instrukcje strukturalne są
konstrukcjami językowymi zbudowanymi z ciągów instrukcji na podstawie
określonych schematów strukturyzacji .
6.2.1 Instrukcje złożone
Instrukcja złożona ma następującą budowę :
BEGIN
I1; I2 ; ...In
END
gdzie I1; I2 ; ...In są instrukcjami a słowa kluczowe BEGIN i
END reprezentujÄ… tzw. nawiasy instrukcyjne .
Instrukcja złożona zastępuję więc ciąg instrukcji , a właściwie to zamienia
ciąg instrukcji w jedną instrukcję .Takie podejście jest bardzo użyteczne ,
gdy musimy użyć wielu instrukcji natomiast składnia dopuszcza tylko
jednÄ… .
Separatorem instrukcji jest średnik  ;  . występuje on pomiędzy
każdymi dwoma instrukcjami . Możemy go również postawić po ostatniej
instrukcji , wtedy oddzieli on tą instrukcję od następnej - tym przypadku
będzie to instrukcja pusta .
6.2.2 Instrukcja warunkowa
Instrukcja wyboru warunkowego :
IF warunek THEN instrukcja_1
ELSE instrukcja_2
Języki programowania -Pascal Strona 25
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Nie
Tak
Test
Instrukcja 1 Instrukcja 2
Instrukcja 3
Instrukcja ta jest równoważna schematowi . W schemacie może być
opuszczona instrukcja 2 , a w składni możebyć opuszczona fraza ELSE .
IF warunek THEN instrukcja_1
Warunek musi być wyrażeniem logicznym(Boolean), czyli dającym w
wyniku wartość boolowską: True lub FALSE.
Natomiast Instrukcja1 i Instrukcja2 muszą być pojedynczymi instrukcjami.
Przykłady :
(a) IF X<>0 THEN y := 1/x ELSE write('Dzilenie
przez 0 ');
(b) IF (X>0) AND(X=1) THEN ELSE y:= 1/x;
(c) IF B < 0 THEN y:= B - 3 ELSE ;
ELSE w przykładzie (c) może być pominięte , w przykładzie (b) można go
pominąć zmieniając warunek na przeciwny czyli
(b`) IF NOT( (X>0) AND(X=1) ) THEN
y:= 1/x;
Języki programowania -Pascal Strona 26
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
(d) IF delta > 0 then
begin
x1:= (-b - Sqrt(delta))/(2*a);
x2:= (-b - Sqrt(delta))/(2*a);
end
ELSE
begin
x1:= -b /(2*a);
x2:=x1;
end;
Ponieważ w składni instrukcji warunkowej występują pojedyncze
instrukcje , a my musieliśmy użyć ich ciągi zastosowaliśmy instrukcje
złożone , które zamieniło nam ciągi instrukcji w pojedyncze instrukcje .
Instrukcja występująca po THEN czy też po ELSE może być również
instrukcjÄ… warunkowÄ… IF
Np
IF test1 THEN
IF test2 THEN
IF test3 THEN
Instrukcja1
ELSE
ELSE
ELSE
co uwidacznia następujący schemat blokowy
True True
True
Test 3
Test 2 Instrukcja 1
Test 1
False False False
Języki programowania -Pascal Strona 27
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
(e)IF delta > 0 then
begin
x1:= (-b - Sqrt(delta))/(2*a);
x2:= (-b - Sqrt(delta))/(2*a);
end
ELSE IF delta = 0
begin
x1:= -b /(2*a);
x2:=x1;
end
ELSE
Write('Nie ma pierwiastków rzeczywistych');
Przykład: Program ten
program oceny;
przyporzÄ…dkuje
var ocena:real;
wynikowi
wynik:integer;
z zakresu 1 - 100
Begin
punktów
wynik:=90;
odpowiedniÄ…
IF wynik >=30 then
ocenÄ™. Punkty
IF wynik >=35 then
określają procent
IF wynik >=40 then
odpowiedzi
IF wynik >=50 then
poprawnych.
IF wynik >=60 then
Układ
IF wynik >=70 then
konstrukcji
IF wynik >=80 then
IF...THEN .
IF wynik >=90 then
..ELSE
Ocena:=5.0
pokazuje nam ,
ELSE Ocena:=4.5
że program ten
ELSE Ocena:=4.0
składa się z
ELSE Ocena:=3.5
wielu
ELSE Ocena:=3.0
zagnieżdżonych
ELSE Ocena:=2.5
ELSE Ocena:=2.0 instrukcji warun-
ELSE Ocena:=1.5 kowych.
ELSE Ocena:=1.0;
writeln(ocena:4:1);
End.
Języki programowania -Pascal Strona 28
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
program ifelse;
Poddajmy dogłębnej analizie
var test,test2:boolean;
przytoczony przykład programu.
l1,l2:integer;
Wyrażenie widzimy tu dwie
Begin
instrukcje warunkowe . Jednak
test:=25*26<27*24;
odnajdujemy tylko jedno słowo
IF test then
ELSE , co oznacza , ze jedna
IF l2<>0 then
instrukcja jest postaci
writeln(l1/l2)
IF...THEN...ELSE
ELSE writeln('Test
natomiast druga
False');
IF...THEN...
End.
Należy postawić sobie pytanie , do
którego IF odnosi się to ELSE ?
Myślę , że bardzo pomocne byłoby tu stworzenie schematu blokowego
True
True
L1/L2
Test l2<>0
False
False
Test False
Na jego podstawie widzimy wyraz
nie , sposób wykonywania naszej
instrukcji warunkowej .
6.2.3 Instrukcja wyboru CASE
Składnia instrukcji CASE jest następująca
CASE selektor OF
pierwsza lista stałych wyboru : I1;
druga lista stałych wyboru : I2;
n-ta lista stałych wyboru : In
ELSE Ie;
END ;
Języki programowania -Pascal Strona 29
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
gdzie I1..In,Ie są instrukcjami prostymi lub złożonymi , selektor jest
wyrażeniem typu porządkowego ( Integer,Char,Boolean ale NIE
Real ).
Listy stałych są albo wymienionymi wartościami
np 1,2,57
albo przedziałami np 1..9
albo połączeniem np 0..9,11,12,17..35
Przykład 2
program Wybor;
Przykład 1:
var droga : char;
Case wynik DIV 10 of
czas : real;
10,9 : Ocena:=5.0
begin
8 : Ocena:=4.5
Read(Droga);
7 : Ocena:=4.0
Case droga of
6 : Ocena:=3.5
''A','a' :
5 : Ocena:=3.0
czas:=3.0;
4 : Ocena:=2.5
3 : Ocena:=2.0
'B','b': czas :=4.0;
0,1,2 : Ocena:=1.0
''C','c' : czas :
End;
=4.5;
ELSE czas :=0;
end;
end.
Instrukcja CASE w wielu przypadkach jest bardziej czytelna niż połączenie
wielu zagnieżdzonych instrukcji IF .Dobrym przykładem może tu być
wyliczanie ocen .
Zarówno w każdej z instrukcji IF jak i w instrukcji CASE mogą być
opuszczone fragmentu zawierajÄ…ce instrukcje wykonywane w przypadku
niespełnienia warunku (w CASE żadnego z warunków).
W instrukcji CASE ELSE może nie występować w niektórych
implementacjach Pascala , standard Pascala jej nie zawiera - jest to jednak
poprawna konstrukcja Turbo Pascala
Program realCase;
var x:real; a:integer;s:string;
begin
read(a);
Języki programowania -Pascal Strona 30
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
x:=sqrt(a)/a;
CASE x OF
1: s:='Liczba dodatnia';
-1: s:='Liczba ujemna';
0: s:='Liczba 0'
end;
writeln(s);
end.
Czy ten program jest poprawnie zbudowany . Widzimy tu błędne użycie
instrukcji CASE . Nie jest dozwolone , aby selektor był wyrażeniem
(zmienna czy też stałą ) rzeczywistym .
Należy w instrukcji CASE wyrażenie x zastąpić Trunc(x). Wynikiem tej
funkcji jest część całkowita z liczby x .
Program nie będzie działał poprawnie , gdy podamy liczbę 0.
6.3 Instrukcje iteracyjne
Iteracje ( pętle) pozwalają na opisani w prosty sposób czynności które są
wykonywane wielokrotnie . W języku Pascal istnieją dwa rodzaje pętli
Treść pętli
Czy
Nie
spełnione są
warunki
wejścia ?
Czy
Tak
spełnione są
Tak warunki
wyjścia ?
Treść pętli
Nie
Języki programowania -Pascal Strona 31
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
6.3.1 Instrukcja FOR
Zm:=wp
Składnia instrukcji :
FOR zm:=wp TO wk DO I ;
gdzie
False
Zm <= wk
zm - Zmienna sterująca pętlą
wp - wartość początkowa
Zm:=succ(zm)
True
wk - wartość końcowa
I
I - pojedyncza instrukcja
Instrukcja OR jest realizacją pętli z warunkiem wejścia . Jest ona pewnym
wariantem pętli WHILE.
6.3.2
Zm:=wp Składnia instrukcji :
FOR zm:=wp DOWNTO wk DO
I ;
gdzie
False
Zm >= wk
zm - Zmienna sterująca pętlą
wp - wartość początkowa
Zm:=pred(zm)
True
wk - wartość końcowa
I
I - pojedyncza instrukcja
Pętla FOR to przykład iteracji ograniczonej  z góry wiadomo ile razy
wykona się dana pętla.
UWAGA!
W treści pętli nie wolno zmieniać wartości zmiennej sterującej pętlą.
Przykład:
var zn:char;k:Integer;
begin
zn:='*';
for k:=1 to 8 do
write(zn:k);
end.
PROGRAM Reprezentacja;
Języki programowania -Pascal Strona 32
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Uses Crt;
VAR znak : Char;
BEGIN
Writeln('Program drukuje kody ASCII znakow');
FOR znak:='0' TO '9' DO
Writeln('cyfra ',znak,' ma kod ',Ord(znak));
FOR znak:='A' TO 'Z' DO
Writeln('litera ',znak,' ma kod ',Ord(znak));
REPEAT UNTIL Keypressed;
END.
program srednia;
uses crt;
var
i,ilosc,suma,a:integer;
wynik:real;
begin
clrscr;
writeln('Program oblicza srednia arytmetyczna');
write('Podaj ilosc liczb z ktorych oblicze
srednia: ');
suma:=0;{przypisanie wartosci poczatkowej sumie}
readln(ilosc);
for i:=1 to ilosc do
begin
write('Podaj liczbe ',i,' a',i,'= ');
readln(a);
suma:=suma+a;
end;
wynik:=suma/ilosc;
writeln('Srednia z podanych liczb wynosi ' ,
wynik:2:2);
writeln('Nacisnij klawisz ENTER');
readln;
end.
Języki programowania -Pascal Strona 33
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
PROGRAM Suma_liczb_parzystych;
USES Crt;
CONST n=100 ;
VAR
suma,licznik : Integer;
BEGIN
ClrScr;
Writeln('Program sumuje liczby parzyste od 1
do ',n);
suma:=0;
FOR licznik:=1 to n DO
IF NOT Odd(licznik) THEN suma:=suma+licznik;
Writeln;
Writeln('Suma liczb przystych od 1 do ', n,'
wynosi ', suma);
ReadLn
END.
6.3.3
Języki programowania -Pascal Strona 34
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
6.3.4 Instrukcja
WHILE
WHILE wl DO I ;
gdzie
wl - wyrażenie logiczne
False
WL
I - pojedyncza instrukcja
Składnia
instrukcji :
True
I
Instrukcja WHILE jest realizacją pętli z warunkiem
wejścia .Instrukcja oznacza: Dopóki prawdziwe jest
wyrażenie WL wykonuj instrukcję I .
Przykłady :
Program Gwazdka; Program Liczby;
var zn:char;k:Integer; uses crt;
begin begin
zn:='*'; i:byte;
k:=1;
i:=0;
while k<=8 do
while i<10
begin do
write(zn:k); begin
k:=k+1; i:=i+1;
end; writeln(i);
end;
end.
xxx
PROGRAM Petla2;
USES Crt;
VAR i, x, y, Nwd : Integer;
BEGIN
ClrScr;
Write('Podaj 1-sza liczbe : ');
ReadLn(x);
Write('Podaj 2-ga liczbe : ');
ReadLn(y);
i:=1;
WHILE (x>i) Or (y>i) DO
Begin
If (x Mod i=0) And (y Mod i=0) Then Nwd:=i;
i:=i+1;
End;
Write('Najwiekszy wspolny dzielnik = ', Nwd);
ReadKey;
END.
6.3.5 Instrukcja
Repeat
Składnia instrukcji :
REPEAT I1; ... In UNTIL wl ;
I1;
gdzie
... wl - wyrażenie logiczne
I1, ..,In - instrukcje
In;
True
WL
False
Instrukcja REPEAT jest realizacją pętli z warunkiem wyjścia. Instrukcja
oznacza: Wykonuj instrukcję I1,..,!n aż prawdziwe będzie wyrażenie WL .
Dowolna pętla zrealizowana za pomocą instrukcji WHILE może być
zbudowana za pomocÄ… instrukcji REPEAT. Twierdzenie odwrotne nie jest
prawdziwe .
Przykład :
Read(zn); WHILE zn <>'*' do
 begin Uses CRT;
write(zn); Var
read(zn); licz:byte;
end;
writeln; Begin
REPEAT zn <>'*' ClrScr;
read(zn); REPEAT
if zn <> '*' then Write('Wpisz jakÄ…Å›
write(zn); liczbÄ™ (0-wyjscie) :
UNTIL zn =*' ');
writeln ReadLn(licz);
WriteLn('Potega
liczby ',licz,' to
',licz*licz);
WriteLn;
UNTIL licz=0;
End.
Przykład:
PROGRAM Petla3;
USES Crt;
VAR n, x : Integer;
y : Real;
Zn : Char;
BEGIN
ClrScr;
Write('Podaj X : ');
ReadLn(x);
y:=1;
n:=1;
REPEAT
Write('N = ', n:3);
y:=x/n;
WriteLn(' X/N = ', y:7:2);
n:=n+1;
UNTIL y<0.2;
Repeat Until KeyPressed
END.
6.4 Inne instrukcje
6.4.1 Instrukcja kodu
Posiada następującą składnię:
INLINE (lista_elementów);
Wszystkie elementy lis ta_elementów oddzielone są od siebie
ukośnikami i mogą być:
stałymi określającymi wartości liczbowe
identyfikatorami zmiennych
identyfikatorami zmiennych ze stałą poprzedzoną + lub -
operatorami rozmiaru kody
Przykładowe użycie tej procedury:
INLINE($EA/$F0/$FF/$00/$F0); {spowoduje
zresetowanie siÄ™ komputera}
6.4.2 Instrukcja asemblerowa
Składnia jej jest następująca:
ASM
Przykład
Instrukcja;
asm
...
mov al,0edh
Instrukcja;
out 60h,al
END;
in al,64h
mov al,x
end;
6.4.3 Instrukcja skoku
Label etykieta
Begin
...
Goto etykieta
...
etykieta:
Instrukcja ta może być przyczyną zaciemniania kodu programu i należy jej
unikać.
Praogam dane;
Label Wyjscie:
...
Bebin
For I:=1 to 1000 do
For j:=2 to 2000 do
For k:=3 to 3000 do
Begin
...
If t[I,j,k]=0 then goto wyjscie
else
...
End;
Write('Brak zera'); exit;
Wyjscie:
Write('Zero na pozycji i,' ',j,' ',k)
End;
6.4.4 Instrukcje Break i Continue
Break  przerwanie treści bloku pętli
Continue  Opuszczenie reszty treści bloku pętli
Program BC;
var i,x,y:Integer;
begin
Write ('podaj dwie liczby całkowite');
for i:=1 to 32000 do
begin
Read(x,y);
if (x=0) and (y=0) then break;
 if (x=0) or (y=0) then continue;
writeln(x/y:5:2, ' ' , y/x :5:2);
end
end.
Języki programowania -Pascal Strona 41
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
7 Typy danych c.d.
7.1 Typy wprowadzone wcześciej
·ð Typy caÅ‚kowite
Byte, Short, Integer, Word, Longint
·ð Typy rzeczywiste
Real, single, double, extended
·ð Typ Logiczny Boolean
·ð Typ Znakowy Char
·ð Typ Napisowy String
Typ String jest równoważny String[255] co oznacza
tablicę 255 znaków.
7.2 Typ wyliczeniowy
Typ definiowany przez użytkownika.
Type Dni=(Poniedzialek, Wtorek, Sroda, Czwartek,
Piatek, Sobota, Niedziela);
var d:dni;
begin
for d:= Poniedzialek to piatek do
writeln ('DziÅ› do pracy ');
end.
7.3 Typ okrojony
Typ okrojony może być utworzony z dowolnego typu prostego (całkowite,
logiczny, znakowy, wyliczeniowy) poprzez zawężenie jego zakresu do
jawnie podanego.
Type LiteraMała =  a .. z ;
Cyfra = 0..9;
Dzienroboczy= Poniedzailek..PiÄ…tek;
Wielkość zajętej pamięci przez typ okrojony jest taka sama jak przez typ
bazowy.
7.4 Typ zbiorowy
Type Nazwa = Set of Typ_ Elmenetowy
Języki programowania -Pascal Strona 42
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Typ zbiorowy umożliwia na operowanie podzbiorach typu
Typ_Elementowy. Typ_Elementowy musi być typem porządkowym
o co najwyżej 256 różnych wartościach. Może to być typ okrojony bądz

wyliczeniowy.
Nie może to być typ Integer  bo zawiera za dużo możliwych wartości.
Type Dni=
(Poniedzialek,Wtorek,Sroda,Czwartek,Piatek,
Sobota,Niedziela);
Robocze =set of Dni;
var d : dni;
r : Robocze;
begin
r:=[];
r :=r+ [poniedzialek..Piatek];
randomize;
d:=dni(random(7)+1);
if d in r then
writeln (' Dzień roboczy',byte(d))
else
writeln('Dzień wolny', byte(d));
end.
Języki programowania -Pascal Strona 43
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
7.5 Typ tablicowy
Jest to typ złożony.
Array[typ_indeksowy]of typ_danych;
Przykład:
Type Liczby= Array[1..10] of byte;
Nazwiska= Array[100..1000] of String;
Dane=Array[Boolean]of Real;
Zadania=Array[Poniedzialek..Piatek]of String;
Typ danych może być dowolnym wcześniej określonym typem.
Program T1; Program T1a;
Var Var
a:array[1..5] of a:array[1..5] of
Integer; Integer;
i:byte;
Begin
Begin
ReadLn(a[1]); for i :=1 to 5 do
ReadLn(a[i]);
ReadLn(a[2]);
ReadLn(a[3]); for i :=5 downto 1 do
WriteLn(a[i]);
ReadLn(a[4]);
E
ReadLn(a[5]);
nd.
WriteLn(a[5]);
WriteLn(a[4]);
WriteLn(a[3]);
WriteLn(a[2]);
WriteLn(a[1]);
End.
Zmienna typu tablicowego w pamięci zajmie
Wielkość jednego elementy * Ilość Elementów
W powyższym przypadku SizeOf(Integer)* 5 czyli 2*5 = 10.
Języki programowania -Pascal Strona 44
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
7.5.1 String
Typ String jest równoważny String[255] co oznacza tablicę
255 znaków. Jest to maksymalna długość pojedynczego łańcuch.
Można ograniczyć go poprzez konstrukcję:
String[B]
gdzie B jest typu Byte 0..255
var Imie : String[15];
Nazwisko : String[25];
Typ String jest specyficznym typem tablicowym.
Dopuszczalne sÄ… oracje na zmiennej
Operatory:
+ = <> < > <= >=
var S: String;
Read(s);
Write(s);
S:= Ala ma kota
S:= Coś innego +  może jeszcze coś ;
If s =>  tekst then Delete(s,2,10);
Funkcje i procedury operujÄ…ce na elementach typu String:
f.Length(S: String): Integer;
f.Copy(S: String; Index: Integer; Count:
Integer): String;
f.Concat(s1 [, s2,..., sn]: String): String;
f.Pos(Substr: String; S: String): Byte;
p.Insert(Source: String; var S: String;
Index: Integer);
p.Delete(var S: String; Index: Integer;
Count:Integer);
Pos(Substr: String; S: String): Byte;
var
s: string;
begin
s := 'Ala ma kota';
Delete(s,5,3); Writeln(s); { 'Ala kota' }
Insert('znalazła',s,5);
Writeln(s); { 'Ala Znalazła kota' }
end.
Języki programowania -Pascal Strona 45
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
7.5.2 Tablice wielowymiarowe
W konstrukcji
Array[typ_indeksowy]of typ_danych;
nic nie powiedziano o typ_danych. Może to być dowolny określony
wcześniej, lub w tym momencie, typ danych. W szczególności może to być
typ tablicowy.
7.5.2.1 Tablice dwu-wymiarowe
Array[zakres1] of array [zakres2] of typ_danych
Array[zakres1,zakres2] of typ_danych
T2a=Array [1..10,1..20] of Real;
T2b=Array [ char,1..3] of Char;
T2c=Array [32..255,Boolean] of Byte;
Ilość elementów tablicy równa się iloczynowi mnogości typów
indeksujących. Np. T2a posiada 10*20 czyli 200 elementów * 4B(typ
Real), czyli Å‚Ä…cznie 800B.
Cała tablica musi zmieścić się w jednym segmencie danych 64KB.
Przykład:
Var T: array['a'..'z',1..3] of byte;
C:char;I:byte;
Begin
Randomize;
For c:= 'a' to 'z' do
For I:=1 to 3 do
T[c,I]:=Random(2);
For I:=1 to 3 do
begin
For c:= 'a' to 'p' do
If T[c,I]>0 then Write('*')
Else write(' ');
Writeln;
End;
END.
Co oznaczajÄ… symbole T, T[c] , T[c,i].
Języki programowania -Pascal Strona 46
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Przykład:
Program Przekatne;
const N=6; M=7;
Type Tablica2= Array[1..N,1..M] of char;
var
T : Tablica2;
i,j,k,p:Integer;
BEGIN
Randomize; k:=1;
For i:=1 to N do
for j:=1 to M do
T[i,j]:= chr(random(255-32)+32);
for i:=1 to N do begin
for j:=1 to M do
write(ord(t[i,j]):4);
writeln
end;
if N for i:=1 to K do
writeln(ord(t[i,i]):i*4);
for i:=1 to K do
writeln(ord(t[i,M-i+1]):(M-i+1)*4);
p:=K div 2;
for i:=1 to p do
writeln(ord(T[i,i]):i*4,
ord(T[i,M-i+1]):(M-2*i+1)*4);
if odd(m) then
begin
inc(p); writeln(ord(T[p,p]):p*4)
end;
for i:=p+1 to K do
writeln(ord(t[i,M-i+1]):(M-i+1)*4,
ord(T[i,i]):(2*i-M-1)*4);
END.
7.5.2.2 Algorytmy dotyczÄ…ce tablic
Języki programowania -Pascal Strona 47
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
PROGRAM SortowanieBabel ;
CONST N = 10 ;
VAR A : ARRAY[1..N] OF Integer ;
I,ZAM: Integer ;
B : Integer ;
BEGIN
Randomize;
FOR I := 1 TO N DO
A[I]:=Random(199)-100;
Writeln('Wylosowany wektor:') ;
Writeln ;
FOR I := 1 TO N DO
Write(A[I]:5) ;
REPEAT
ZAM := 0 ;
FOR I := 1 TO N - 1
DO BEGIN
IF A[I]> A[I+1]
THEN BEGIN
B := A[I];
A[I] := A[I+1];
A[I+1] := B;
ZAM := ZAM + 1
END
END
UNTIL ZAM = 0 ;
Writeln('Wektor po sortowaniu:') ;
Writeln ;
FOR I := 1 TO N DO
Write(A[I]:5) ;
END.
Języki programowania -Pascal Strona 48
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
7.5.2.3 Tablice n-wymiarowe
Type
Pozycja =[-10..10,-10..10,-10..10] of real;
Tab3= Array [1..3,1..10,1,5] of Boolean;
Tab4= Array[Boolean,1..3,6..10,2..4]of Real;
Tab5= Array[1..2,1.10,1..5,1..4,0..9] of
Integer;
Type
Punkt = Array[1..3] of Real;
Odcinek = Array[1..2] of Punkt;
Figura = Array[1..4] of Punkt;
Bryla = Array[1..6] of Figura;
Ruch = Array[1..100] of Bryla;
Nie istnieje ograniczenie, poza zajętością pamięci, na ilość wymiarów
tablicy. Jednakże niezmiernie rzadko stosuje się tablice o większej
ilości niż 3. Najczęściej pojawiają się tablice jedno i dwu wymiarowe.
Większa ilość wymiarów utrudnia określenie adresu elementu, a także
zależności pomiędzy sąsiadami.
Czasami lepszym rozwiÄ…zaniem jest skonstruowanie prostszego typu
danych.
Załóżmy za var B:Bryła;
Co oznaczają zmienne i czy poprawne są odwołani:
B, B[1], B[1,2], B[1,2,3], B[1,2,3,4], B
[1,2,3,4,5]
7.5.2.4 Zgodność typów tablicowych
Type T1=Array[1..N] of integer;
T2=Array[1..N] of integer;
Var a1:T1; a2:T2;
a1:=a2; a1:=T1(a2);
Języki programowania -Pascal Strona 49
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
8 Podprogramy
8.1 Istota programowania proceduralnego
Historycznie ujmując pierwsze programy korzystały z programowania
liniowego. Nie wspominam tu z oczywistych względów języków
maszynowych, czy też  języków programowania pierwszych komputerów.
Programowanie proceduralne umożliwia podział jednego wielkiego projektu
na kilka mniejszych zadań.
8.1.1 Pojęcie procedury
Procedure NazwaProcedury ( var argument : Typ_argumentu ) ;
,
;
Deklaracje stałych i zmiennych lokalnych;
Begin
Ciało procedury
End;
8.1.2 Pojecie funkcji
Function NazwaFunkcji ( var argument : Typ_argumentu )
,
;
: Typ_wyniku ;
Deklaracje stałych i zmiennych lokalnych;
Begin
...
NazwaFunkcji:=wyrażenie typu Typ_wyniku;
...
End;
Języki programowania -Pascal Strona 50
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
8.1.3 Deklaracje, definicja i wywołanie
podprogramów
8.1.3.1 Procedury
Program podprogramy;
Procedura powieksz(var x:real;y:real);
Begin
X:=x+y;
End;
Var x,y : real;
BEGIN
x:= 2.0; y:= 1.0;
Writeln(x,  ,y);
Powieksz(x,y)
Writeln(x,  ,y);
END.
8.1.3.2 Funkcji
Program Funkcje;
Function Silnia(N:byte):longint;
Var i:Byte;
S: longint;
Begin
S:=1;
For i:=1 to N do s:= s * i;
Silnia:=s;
End;
Function Potega(x:real;N:byte):Real;
Var i:Byte;
P: longint;
Begin
P:=1;
For i:=1 to N do p:= p * x;
Potega:=p;
End;
Var w,a:real; b:byte;
Begin
a:= 2.0; b:= 3;
Writeln(b, != silnia(b));
Języki programowania -Pascal Strona 51
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
w:= pot(a,b);
Writeln(a, ^ ,b, = ,w);
End.
8.1.4 Parametry podprogramów
8.1.4.1 Parametry formalne i aktualne, zmienne lokalne
Parametry podprogramów umożliwiają komunikację procedury ze  światem
zewnętyrznym , czyli programem głównym bądz
innym podprogramem,
który go wywołał. Dzięki parametrom podprogramy działając na
sparametryzowanych danych mogą być wielokrotnie używane do
wykonywania zadań na różnych danych. Parametry procedur i funkcji stają
się ich zmiennymi lokalnymi. Jeśli jakaś zmienna globalna ma nazwę
tożsamą z nazwą parametru to w podprogramie będzie widoczna tylko
zmienna lokalna zwiÄ…zana z parametrem.
8.1.4.2 Przekazywanie parametru poprzez wskaz
nik i wartość
Program Parametr_var;
Procedure Dordaj( var x:Integer; y : Integer);
Begin
x := x + 2;
y := y + 3;
writeln('x =', x ,'y=',y );
End;
BEGIN
x := 5;
y := 6;
writeln('x =', x ,'y=',y );
dodaj( x, y);
writeln('x =', x ,'y=',y );
END.
8.1.5 Inne przykładowe funkcje
·ð Zamiana dwóch zmiennych liczbowych
·ð Maximum i minimum
·ð Podprogramy operujÄ…ce na elementach tablicy
8.1.6 Zalety programowanie z wykorzystaniem
podprogramów
·ð PodziaÅ‚ programu na mniejsze segmenty
·ð Wielokrotne wykorzystanie tego samego kodu
Języki programowania -Pascal Strona 52
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
·ð Realizacja podobnych problemów za pomocÄ… tego samego podprogramu 
wykorzystanie parametrów
8.1.7 Rekurencja
8.1.7.1 Cechy rekurencji
8.1.7.2 Wywoływanie samej siebie
8.1.7.3 W pewnych warunkach następuje koniec wywoływania
rekurencyjnego
8.1.7.4 Rekurencja a iteracja
Program Rekurencja;
Function Silnia(N:byte):longint;
Begin
If N>0 then silnia:= n*silnia(N-1)
Else silnia:=1;
End;
Function Potega(x:real;N:byte):Real;
Begin
If N>0 then potega:= x*potega(x,N-1)
Else potega:=1;
End;
Procedure Hanoi(zlodlo,pomoc,cel,ilosc:byte);
Begin
If ilosc>0 then
begin
Hanoi(zrodlo,cel,pomoc,ilesc-1);
Przenies(zrodlo,cel);
Hanoi(pomoc,zrodlo,cel,ilesc-1);
End;
End;
Gdzie procedura przenies może mieć w najprostszym przepadku postać:
Procedure przenies(zrodlo,cel:byte);
Begin
Write(zrodlo, -> ,cel,  );
End;
Języki programowania -Pascal Strona 53
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Ciekawszym rozwiązaniem, byłoby wykorzystanie tablic do
przechowywania krążków (liczb) i wyświetlania ich zawartości. To
umożliwiło by zasymulowanie animacji.
Można też by zauważyć, że skoro zmienne zlodlo,pomoc,cel są
liczbami powiedzmy 1, 2, 3 to łatwo zauważyć, iż
1 + 2 +3 = 6 .
zlodlo+pomoc+cel = 6 czyli
cel =6-zlodlo-pomoc
a procedurę mo zemy zamienić na:
Procedure Hanoi(zlodlo,pomoc,ilosc:byte);
8.1.7.5 Zalety i wady rekurencji
üð ZastÄ™puje iteracjÄ™
üð Prostota krótkiego kodu
¾ð A
atwe przepełnienie stosu
¾ð KÅ‚opoty z rekurencyjnÄ… definicjÄ… problemu
Języki programowania -Pascal Strona 54
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
9 Rekordy i tablice rekordów
9.1 Istota typu rekordowego
Typ rekordowy jest używany do opisu obiektów o strukturze niejednorodnej,
czyli takich, w których elementy składowe zawierają dane różnych typów. W
ten sposób możemy połączyć w jedną całość wiele różnych informacji. Jako
przykład może posłużyć zbiór informacji o studencie.
9.2 Rekordy z częścią stałą
Deklaracja typu rekordowego będzie miało następujący schemat.
Type Nazwa_typu = RECORD
Pierwsza_lista_pól:T1;
Druga_lista_pól :T2;
n-ta lista_pól:TN;
END;
Gdzie każda lista pól to lista identyfikatorów oddzielonych on siebie
przecinkami, a każde Ti to identyfikator dowolnego wcześniej
zdefiniowanego, przez użytkownika bądz
systemowego, typu.
DataT=Record
d,m,r:byte;
end;
AdresT=Record
ulica :string[20];
miasto:string[15];
kod :string[5];
end;
Dane=record
imie:String[15];
nazwisko:string[25];
data_ur:DataT;
rok:0..6;
adres:AdresT;
wydzial,kierunek:byte;
end;
var D:Dane;
Języki programowania -Pascal Strona 55
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Dostęp do pól rekordu mamy za pomocą znaku  . (kropka) oddzielającej
nazwÄ™ zmiennej od nazwy pola.
D.imie
D.Data_ur.d
9.2.1 Instrukcja wiążąca WITH
Instrukcja postaci:
With zmienna_recordowa do
Instrukcja;
powoduje, że w obrębie instrukcji Instrukcja mamy dostęp do pól
zmiennej zmienna_recordowa bez konieczności pisania desygnatora w
pełnej postaci.
With D do
Begin
Write( Podaj imiÄ™  );
Readln(imie);
Write( Podaj nazwisko  );
Readln(nazwisko);
Write( Podaj datÄ™ urodzenia (rr mm dd)  );
With data_ur do
Readln(r,m.,d);
...
End;
9.2.2 Rekord z wariantami
Pola opisane w poprzednim rekordzie są dostępne we wszystkich zmiennych
tego typu. Możliwa jest również struktura, w której w zmiennych
rekordowych tego samego typu istnieją różne pola. Pojawienie się kilku
wariantów zmiennej rekordowej umożliwia konstrukcja:
Type Nazwa_typu = RECORD
Definicje pól stałych;
CASE pole znacznikowe : Tc OF
Pierwsza lista stałych wyboru:(Pierwsza
lista pól);
Druga lista stałych wyboru:(Druga lista
pól);
...
M-ta lista stałych wyboru:(M-ta lista pól);
END;
Języki programowania -Pascal Strona 56
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Gdzie pole znacznikowe oznacza pole typu Tc (pole to może być
opuszczone, ale typ musi być określony). Pola w wariantach mogą różnić się
zarówno typem jak i ilością. Przy przydzielaniu pamięci kompilator dla
całego wariantu przydzieli tyle pamięci ile zajmuje sumarycznie największa
z list pól wariantowych. W poniższym przykładzie będzie to 26 bajtów /
sizeof(string[25])/.
Ważne jest, że END kończy zarówno wariant jak i cały opis typu
rekordowego  powoduje to, że nie istnieje możliwość zdefiniowania
większej niż 1 ilości wariantów.
Type
Tplec=(K,M);
Dane=record
imie:String[15];
nazwisko:string[25];
data_ur:DataT;
rok:0..6;
adres:AdresT;
wydzial,kierunek:byte;
case plec:Tplec of
M:( Nazwajw:string[15];
Nrjw:word; );
K:(NRodowe:string[25])
end;
Dostęp do pól wariantowych jak i pola znacznikowego jest taki sam jak w
przy padku innych pól.
Języki programowania -Pascal Strona 57
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
10 Operacje wejścia  wyjścia
10.1 Podstawowe operacje na plikach
Większość programów w trakcie pracy
wykorzystuje pliki do przechowywania danych. Dotychczas przechowywałeś
dane w pamięci operacyjnej, tzn., że po zakończeniu programu twoje
dane ulegały zniszczeniu, po przeczytaniu tego rozdziału to się zmieni.
Ze względu na typ danych przechowywanych w plikach możemy wyróżnić:
·ð pliki tekstowe - zawierajÄ…ce tekst ;
·ð pliki elementowe (zdefiniowane) - elementami tych plików sÄ…:
tablice, rekordy;
·ð pliki amorficzne - o nieokreÅ›lonej strukturze.
Pierwszą rzeczą w momencie rozpoczęcia pracy na plikach jest stworzenie
zmiennej plikowej,
robimy to tak:
var
nazwa_zmiennej : text; plik tekstowy
nazwa_zmiennej : file of typ: plik zdefiniowany;
nazwa_zmiennej : file plik o nieokreślonej
strukturze;
Zanim zaczniemy wykonywać jakiekolwiek operacje na pliku musimy
zadeklarowanej zmiennej przypisać "fizyczną" nazwę pod jaką plik
będzie widoczny na dysku, robimy to tak:
Assign(zmienna_plikowa,sciezka);
zmienna_plikowa  wykonując operacje na pliku do niej będziemy
się odwoływać,
sciezka - ścieżka do pliku np.: 'C:\TEMP\PLIK.DAT'
Uwaga:
Procedura Assign nie sprawdza istnienia, a nawet możliwości dostępu do
pliku opisanego ścieżką.
Języki programowania -Pascal Strona 58
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Po skojarzeniu należy plik otworzyć. Mamy do wyboru kilka procedur
otwierajÄ…cych:
·ð Reset(zmienna_plikowa) - otwiera tylko plik już istniejÄ…cy,
brak pliku powoduje wystąpienie błędu fatalnego wejscia-wyjścia. Plik
otwarty do czytania lub czytania i pisania.
·ð Rewrite(zmienna_plikowa) - tworzy plik, jeÅ›li już istnieje to
otwiera plik skojarzony ze zm_plikową. Jeśli plik już istnieje to dane w
nim zapisane zostanÄ… nadpisane. Plik otwarty do pisania.
·ð Append(zmienna_plikowa) - Procedura ta dotyczy tylko plików
tekstowych. Otwiera do pisania istniejÄ…cy plik, (skojarzony ze
zmienną_plikową). Dane będą dopisywane na koniec pliku.
·ð Close(zmienna_plikowa) - zamyka plik skojarzony ze zmiennÄ…
plikowÄ….
·ð Function Eof(zm_Plik):Boolean; Zwraca TRUE gdy
osiągnięty został koniec pliku FALSE w przeciwnym przypadku.
Zapisywanie i odczytywanie danych z pliku odbywa siÄ™ za pomocÄ…
procedur:
Read, Readln, Write, Writeln:
Read(zmienna_plikowa,lista_argumentów);
Write(zmienna_plikowa,lista_argumentów);
Procedury te były już używane wcześniej, pierwszy parametr był wtedy
opuszczany. Oznaczało to operacje na specjalnym pliku tekstowym 
konsoli. Pliku tego można używać jawnie:
var plikwe,plikwy;
...
Assign(plikwe,  );
Assign(plikwy,  );
Reset(plikwe);
Rewrite(plikwy);
...
read(plikwe,n);
for i:=1 to 10 do
writeln(plikwy,'Tekst na ekran(',n,')razy');
Składnia procedur czytania i pisania z plików powinna więc być znana .
10.2 Pliki tekstowe
Języki programowania -Pascal Strona 59
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Konsola  plik tekstowy standardowo otwarty do czytania i pisania.
Metody otwarcia:
Reset  tylko do czytania
Rewrite  tylko do pisania
Append  do aktualizacji, czyli pisania na końcu pliku.
10.2.1 Plik tekstowy a plik file of char
Program pliki_tekstowe;
var
plik_wejsciowy : text;
plik_wyjsciowy : file of char;
znak : char;
begin
Assign(plik_wejsciowy, 'plik.in');
Assign(plik_wyjsciowy, 'plik.out');
{$I-} Reset(plik_wejsciowy); {$I+}
if IOResult <> 0 then exit;
ReWrite(plik_wyjsciowy);
while not EoF(plik_wejsciowy) do begin
Read(plik_wejsciowy, znak);
Write(plik_wyjsciowy, znak);
Write(znak);
end;
Close(plik_wejsciowy);
Close(plik_wyjsciowy);
end.
Języki programowania -Pascal Strona 60
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
10.3 Pliki elementowe
Metody otwarcia:
Reset  do czytania i pisania
Rewrite  tylko do pisania
Append  NIE JEST DOST
PNA, ale w zamian mamy:
Seek, FilePos, FileSize.
PROGRAM Pliki;
USES Crt;
Const ESC_Key =#27;
TYPE Osoba = RECORD
Imie, Nazw : String[15];
Adres : String[50];
Tel : String[10];
END;
PlikOsob = FILE OF Osoba;
Function Tworz(Var Plik : PlikOsob):Boolean;
VAR Nazwa : String;
Begin
Twórz:=False; ClrScr;
Write('Podaj nazwe pliku i sciezke : ');
ReadLn(Nazwa); Assign(Plik, Nazwa);
{$I-} Rewrite(Plik); {$I+}
if IOResult <> 0 then exit;
Twórz:=True
End;
Function Otworz(Var Plik : PlikOsob):Boolean;
VAR Nazwa : String;
Begin
Otwórz:=False; ClrScr;
Write('Podaj nazwe pliku i sciezke : ');
ReadLn(Nazwa); Assign(Plik, Nazwa);
{$I-} Reset(plik); {$I+}
if IOResult <> 0 then exit;
Otwórz:=True
End;
PROCEDURE CzytajRec(Var x:Osoba);
Begin
ClrScr;
Języki programowania -Pascal Strona 61
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Write('Podaj imie : ');
ReadLn(x.Imie);
Write('Podaj nazwisko : ');
ReadLn(x.Nazw);
Write('Podaj adres : ');
ReadLn(x.Adres);
Write('Podaj telefon : ');
ReadLn(x.Tel);
End;
PROCEDURE WypiszRec(Var x:Osoba);
Begin
Writeln('IMIE : ', x.Imie);
Writeln('NAZWISKO : ', x.Nazw);
Writeln('ADRES : ', x.Adres);
Writeln('TELEFON : ', x.Tel);
End;
PROCEDURE DopiszDoPliku(Var Plik : PlikOsob;
x:Osoba);
Begin
Seek(Plik, FileSize(Plik));
Write(Plik, x);
End;
PROCEDURE Wypisz(Var Plik : PlikOsob);
Var x:Osoba;
Begin
Reset(Plik);
While Not Eof(Plik) Do
Begin
ClrScr;
Read(Plik, x);
WypiszRec(x)
If ReadKey=ESC_Key then break;
End;
End;
10.4 Pliki amorficzne
Są to pliki binarne o nieokreślonej strukturze. Procedury otwarcia
Reset(pilk,wielkosc_jednostki)
Rewrite(pilk,wielkosc_jednostki)
Języki programowania -Pascal Strona 62
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
wielkosc_jednostki (Word)  oznacza wielkość pojedynczego
elementu jaki będzie czytane z pliku; domyślnie 128.
procedure BlockRead(var F: File; var Buf; Count:
Word [; var Result:Word]);
procedure BlockWrite(var f: File; var Buf; Count:
Word [; var Result:Word]);
gdzie:
F zmienna plikowa
Buf zmienna buforujÄ…ca dane (Tablica, Wskaz
nik)
Count ilość elementów do odczytania(zapisania)
Result ilość elementów odczytanych (zapisanych);
wynik czytania(pisania)
Nie poprawne jest również sprawdzanie końca pliku poprzez EOF- trzeba
zamiast sprawdzać wartość zmiennej Result
var
FromF, ToF: file;
NumRead, NumWritten: Word;
Buf: array[1..2048] of Char;
begin
Assign(FromF, ParamStr(1));
Reset(FromF, 1);
Assign(ToF, ParamStr(2));
Rewrite(ToF, 1);
Writeln('Copying ', FileSize(FromF),
' bytes...');
repeat
BlockRead(FromF, Buf, SizeOf(Buf), NumRead);
BlockWrite(ToF, Buf, NumRead, NumWritten);
until (NumRead = 0) or (NumWritten <> NumRead);
Close(FromF); Close(ToF);
end.
10.5 Funkcje i procedury operujÄ…ce na plikach
·ð Seek(Plik, n)
Procedura Seek ustawia wskaz
nik pliku przed składową o numerze n.
Plik jest plikiem dowolnego typu z wyjÄ…tkiem typu Text, a n jest
wyrażeniem typu LongInt. Pierwszy składnik pliku ma numer 0. Seek
Języki programowania -Pascal Strona 63
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
może być użyte do rozszerzenia pliku, poprzez ustawienie składnika
pliku na pierwszy za końcem pliku, tzn. Seek(Plik, FileSize(Plik)).
·ð FileSize(Plik)
Funkcja ta zwraca aktualny wymiar pliku. Rezultat jest typu LongInt.
Jeżeli Plik jest plikiem pustym, to FileSize(Plik)=0.
·ð FilePos(Plik)
Funkcja ta podaje aktualnÄ… pozycjÄ™ wskaz
nika pliku. Jeżeli wskaz
nik
pliku znajduje się na początku pliku, to FilePos(Plik)=0. Jeżeli
wskaz
nik pliku znajduje się na końcu pliku, FilePos(Plik)=FileSize
(Plik). Funkcja FilePos może być użyta tylko wtedy, gdy plik jest
otwarty.
·ð Erase(Plik)
Procedura ta wymazuje (usuwa) plik zwiÄ…zany ze zmiennÄ… plikowÄ…
Plik. Nie jest dopuszczalne stosowanie Erase w stosunku do otwartego
pliku. Plik musi być zamknięty przed użyciem procedury Erase.
·ð Rename(Plik, Nowa_nazwa)
Procedura ta zmienia nazwę pliku zewnętrznego związanego ze
zmiennÄ… plikowÄ… Plik.
·ð Truncate(Plik)
Procedura obcina wszystkie składowe pliku poza aktualnym
położeniem wskaz
nika pliku. Aktualne położenie wskaz
nika pliku staje
się końcem pliku.
Języki programowania -Pascal Strona 64
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
11 Biblioteki Turbo Pascala
11.1 Moduł Crt
Moduł CRT zawiera procedury i funkcje obsługi ekranu, dz
więku i
klawiatury.
Pozwala na definiowanie okien, wybór koloru tekstu i jego tła w przypadku
kolorowych kart graficznych, generowanie dz
więku o wybranej
częstotliwości i długości oraz odczytywanie znaków z klawiatury , włącznie
z jej rozszerzeniami.
11.1.1 STALE
- stałe trybów tekstowych.
BW40 = 0; czarno-biały karty kolorowej, 40 kolumn
CO40 = C40 = 1; kolorowy karty kolorowej, 40 kolumn
BW80 = 2; czarno-biały karty kolorowej, 80 kolumn
CO80 = C80 = 3; kolorowy karty kolorowej, 80 kolumn
Mono = 7; czarno-biały karty monochromatycznej, 80 kolumn
Font8*8 = 256; kolorowy karty EGA lub VGA, 43 lub 50 wierszy-
stałe kolorów.
Black = 0; czarny
Blue = 1; niebieski
Green = 2; zielony
Cyan = 3; turkusowy
Red = 4; czerwony
Magenta = 5; karmazynowy
Brown = 6; brÄ…zowy
LightGray = 7; jasnoszary
DarkGray = 8; ciemnoszary
LightBlue = 9; jasnoniebieski
LightGreen = 10; jasnozielony
LightCyan = 11; jasnoturkusowy
LightRed = 12; jasnoczerwony
LightMagenta = 13; jasnokarmazynowy
Yellow = 14; żółty
White = 15; biały
Blink = 128; suma (Blink+kolor) wywołuje
miganie
Języki programowania -Pascal Strona 65
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
wyróżnionego koloru.
11.1.2 ZMIENNE
CheckBreak : Boolean - standardowo: True; wartość ta oznacza, że
polecenie Ctrl-Break działa tak, jak w DOSie.
CheckEof : Boolean - standardowo: False; wartość funkcji Eof(plik)
jest równa CheckEof dla danego pliku tekstowego plik
zwiÄ…zanego z CRT (po odczytaniu znaku generowanego przez
Ctrl-Z)
CheckSnow : Boolean - standardowo: True; wartość ta zabezpiecza
ekran przed śnieżeniem (ważne dla CGA)
DirectVideo :Boolean - standardowo: TRUE
Sposób wyświetlania znaków na ekranie monitora.
True, bezpośrednie działania procedurCRT;
False wykorzystanie procedur z ROM BIOS
LastMode : Word - wartość będąca ostatnim numerem sterownika
ekranu, tzn. przed uruchomieniem programu
TextAttr : Byte - wartość oznaczająca atrybut wyświetlanych znaków
WinMin : Word - zmienna przechowująca współrzędne lewego
górnego rogu bieżącego okna tekstowego (pierwszy bajt(-y),
drugi-x)
WinMin : Word - jw. dla prawego dolnego rogu okna
11.1.3 FUNKCJE I PROCEDURY
11.1.3.1 AssignCrt (var plik: Text) procedura
Wynik : Skojarzenie pliku tekstowego z urzÄ…dzeniem CRT (do realizacji
operacji wej/wyj zwiÄ…zanych z konsola).
11.1.3.2 KeyPressed: Boolean funkcja
Wynik : Wartość True, gdy w buforze klawiatury znajduje się nie odczytany
jeszcze znak.
Uses crt;
begin
repeat until keypressed;
end.
11.1.3.3 ReadKey: Char funkcja
Wynik : Czytanie kolejnego znaku znajdujÄ…cego siÄ™ w buforze klawiatury.
Uses crt;
var kl:char;
begin
Języki programowania -Pascal Strona 66
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
repeat kl:=readkey; unitl kl = chr(27);
end.
11.1.3.4 TextMode (tryb: Byte) procedura
tryb - stała typu tekstowego
Wynik : Zmiana bieżącego trybu tekstowego na nowy tryb
11.1.3.5 Window (x1, y1, x2, y2: Byte) procedura
x1, y2 - współrzędne lewego górnego rogu okna
x2, y2 - współrzędne prawego dolnego rogu okna
Wynik : Zdefiniowanie okna tekstowego o podanych wspolrzadnych lewego
górnego i prawego dolnego rogu okna. Kursor znajdzie się w
lewym górnym rogu okna.
11.1.3.6 GotoXY (x, y: Byte) procedura
x, y - współrzędne znaku w oknie
Wynik : Umieszczenie kursora w kolumnie x i wierszu y bieżącego okna
tekstowego. Punkt (1,1) znajduje się w lewym górnym rogu okna.
11.1.3.7 Funkcja WhereX: Byte { WhereY}
Wynik : Współrzędne x(Y)znaku wskazywanego przez kursor
(bieżąca kolumna).
Uses crt;
Var pozX,pozY:Byte;
begin
poz_x:=wherex;
poz_y:=wherey);
gotoxy(10,10);
write('JAREK');
end.
11.1.3.8 ClrScr procedura
Wynik : Wypełnienie bieżącego okna tekstowego znakami spacji i
umieszczenie kursora w lewym górnym rogu okna.
Uses crt;
begin
clrscr;
write('Przykład');
end.
11.1.3.9 ClrEol procedura
Wynik : Wypełnienie znakami spacji obszaru miedzy pozycja kursora a
końcem wiersza, w którym się kursor znajduje.
Języki programowania -Pascal Strona 67
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
11.1.3.10 InsLine procedura
Wynik : Wsławienie wiersza wypełnionymi spacjami bezpośrednio pod
wierszem, w którym znajduje się kursor. Wiersz ostatni bieżącego
okna tekstowego zostanie usunięty, a wiersze, przed którymi
postawiono ten nowy, przesunięte w dol.
11.1.3.11 DelLine procedura
Wynik : Usuniecie wiersza , w którym w danej chwili znajduje się kursor.
Wiersze położone poniżej zostaną przesunięte w gore, a ostatni
wiersz okna zostanie wypełniony znakami spacji.
11.1.3.12 TextColor (kolor: Byte) procedura
kolor - stała koloru
Wynik : Zmiana kolorów wyprowadzanych znaków (patrz: Stale koloru).
Uses crt;
begin
textcolor(1);
writeln('przykład');
end.
11.1.3.13 TextBackground (kolor: Byte) procedura
kolor - stała koloru
Wynik : Zmiana koloru tła. Możliwy jest wybór jednego z ośmiu kolorów
określonych wartościami od 0 do 7.
Uses crt;
begin
textbackground(2);
textcolor(0);
writeln('Komputer');
end.
11.1.3.14 LowVideo procedura
Wynik : Wyprowadzenie tekstu w kolorze ciemnym, odpowiadajÄ…cym
wcześniejszemu kolorowi jasnemu(numer koloru większy niz. 7).
Dzieje się tak na skutek wyzerowania bitu jasności zmiennej
TextAttr.
11.1.3.15 HighVideo procedura
Języki programowania -Pascal Strona 68
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Wynik : Zmiana koloru wyprowadzanego tekstu z ciemnego na odpowiedni
jasny. Jest to wynikiem ustawienia bitu jasności zmiennej TextAttr
w stan 1.
11.1.3.16 NormVideo procedura
Wynik : Nadanie bitowi jasności zmiennej TextAttr stanu sprzed pierwszego
wywołania procedury HighVideo lub LowVideo.
11.1.3.17 Delay (ms: Word) procedura
ms - liczba milisekund
Wynik : Wstrzymanie wykonywania programu na czas określony
parametrem ms.
Uses crt;
begin
delay(5000);
write('CD');
{wypisanie napisu "CD" po pewnym czasie}
end.
11.1.3.18 Sound (Hz: Word) procedura
Hz - częstotliwość dz
więku w hercach
Wynik : Rozpoczęcie generowania dz
więku o częstotliwości zadanej przez
parametr Hz.
Uses crt;
begin
sound(100);
delay(300);
nosound;
end.
11.1.3.19 NoSound procedura
Wynik : Wstrzymanie generowania dz
więku.
Języki programowania -Pascal Strona 69
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
11.2 Moduł System
Funkcje arytmetyczne:
function Abs(X): (Taki jak typ argumentu);
function ArcTan(X: Real): Real;
function Cos(X: Real): Real;
function Exp(X: Real): Real;
function Frac(X: Real): Real;
function Int(X: Real): Real;
function Ln(X: Real): Real;
function Pi: Real;{.1415926535897932385.}
function Sin(X: Real): Real;
function Sqr(X): (Taki jak typ argumentu);
function Sqrt(X: Real): Real;
Funkcje dynamicznej alokacji pamięci
procedure Dispose(var P: Pointer [ , Destructor ]);
procedure FreeMem(var P: Pointer; Size: Word);
procedure GetMem(var P: Pointer; Size: Word);
procedure New(var P: Pointer[,Init: Constructor]);
function MaxAvail: Longint;
function MemAvail: Longint;
Funkcje kontrolno-sterujÄ…ce:
procedure Exit;
procedure Halt [ ( Exitcode: Word ) ];
procedure RunError [ ( Errorcode: Byte ) ];
Funkcje wejscia-wyjścia
procedure Assign(var f; String);
procedure ChDir(S: String);
procedure Close(var F);
function Eof(var F): Boolean;
procedure Erase(var F);
function FilePos(var F): Longint;
function FileSize(var F): Longint;
procedure GetDir(D: Byte; var S: String);
where D is set to:
0 Default
1 Drive A 2 Drive B 3 Drive C &
function IOResult: Integer;
Języki programowania -Pascal Strona 70
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
procedure MkDir(S: String);
procedure Rename(var F; Newname);
procedure Reset(var F [: File; Recsize: Word ] );
procedure Rewrite(var F: File [; Recsize: Word ] );
procedure RmDir(S: String);
procedure Seek(var F; N: Longint);
procedure Truncate(var F);
Funkcje różne:
procedure Exclude(var S: set of T;I:T);
procedure FillChar(var X; Count: Word; value);
function Hi(X): Byte;
function High(X)
procedure Include(var S: set of T; I:T);
function Lo(X): Byte;
function Low(X);
procedure Move(var Source, Dest; Count: Word);
function ParamCount: Word;
function ParamStr(Index): String;
function Random [ ( Range: Word) ]:
( Taki jak typ argumentu );
procedure Randomize;
function SizeOf: Integer;
function Swap(X): (Taki jak typ argumentu);
function UpCase(Ch: Char): Char;
Funkcje porzÄ…dkowe:
procedure Dec(var X[ ; N: Longint]);
procedure Inc(var X [ ; N: Longint ] );
function Odd(X: Longint): Boolean;
function Pred(X): (Taki jak typ argumentu);
function Succ(X): (Taki jak typ argumentu);
Funkcje zwiazane z adresami i wskaz
nikami:
function Addr(X): pointer;
function Assigned(var P): Boolean;
function CSeg: Word;
function DSeg: Word;
function Ofs(X): Word;
function Ptr(Seg, Ofs: Word): Pointer;
function Seg(X): Word;
function SPtr: Word;
function SSeg: Word;
Języki programowania -Pascal Strona 71
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Funkcje napisowe:
function Concat(s1 [, s2,..., sn]: String): String;
function Copy(S: String; Index: Integer; Count:
Integer): String;
procedure Delete(var S: String; Index: Integer;
Count:Integer);
procedure Insert(Source: String; var S: String;
Index: Integer);
function Length(S: String): Integer;
function Pos(Substr: String; S: String): Byte;
procedure Str(X [: Width[:Decimals]];var S:string);
procedure Val(S; var V; var Code: Integer);
Funkcje zwiÄ…zane z plikami tekstowymi:
procedure Append(var f: Text);
function Eoln [(var F: Text) ]: Boolean;
procedure Flush(var F: Text);
procedure Read(F , V1 [, V2,...,Vn ] );
function SeekEof [ (var F: Text) ]: Boolean;
function SeekEoln [ (var F: Text) ]: Boolean;
procedure SetTextBuf(var F:Text;var Buf[;S:Word]);
procedure Write(F, V1 [, V2,...,Vn ] );
Funkcje konwersji:
function Chr(X: Byte): Char;
function Ord(X): Longint;
function Round(X: Real): Longint;
function Trunc(X: Real): Longint;
Funkcje operujÄ…ce na plikach amorficznych:
procedure BlockRead(var F: File; var Buf; Count:
Word [; var Result: Word]);
procedure BlockWrite(var f: File; var Buf; Count:
Word [; var Result: Word]);
Języki programowania -Pascal Strona 72
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
11.3 Moduł Dos
const
FCarry = $0001;
FParity = $0004;
FAuxiliary = $0010;
FZero = $0040;
FSign = $0080;
FOverflow = $0800;
fmClosed = $D7B0;
fmInput = $D7B1;
fmOutput = $D7B2;
fmInOut = $D7B3;
ReadOnly = $01;
Hidden = $02;
SysFile = $04;
VolumeID = $08;
Directory = $10;
Archive = $20;
AnyFile = $3F;
Type
ComStr = string[127];
PathStr = string[79];
DirStr = string[67];
NameStr = string[8];
ExtStr = string[4];
Registers
FileRec
TextBuf
TextRec
SearchRec
DateTime
var
DosError: Integer;
function DosVersion: Word;
procedure Intr(IntNo: Byte; var Regs: Registers);
Języki programowania -Pascal Strona 73
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
procedure MsDos(var Regs: Registers);
procedure GetDate(var Year,Month,Day,DayOfWeek:
Word);
procedure SetDate(Year,Month,Day: Word);
procedure GetTime(var Hour,Minute,Second,Sec100:
Word);
procedure SetTime(Hour,Minute,Second,Sec100: Word);
procedure GetCBreak(var Break: Boolean);
procedure SetCBreak(Break: Boolean);
procedure GetVerify(var Verify: Boolean);
procedure SetVerify(Verify: Boolean);
function DiskFree(Drive: Byte): Longint;
function DiskSize(Drive: Byte): Longint;
procedure GetFAttr(var F; var Attr: Word);
procedure SetFAttr(var F; Attr: Word);
procedure GetFTime(var F; var Time: Longint);
procedure SetFTime(var F; Time: Longint);
procedure FindFirst(Path: PathStr; Attr: Word;
var F: SearchRec);
procedure FindNext(var F: SearchRec);
procedure UnpackTime(P: Longint; var T: DateTime);
procedure PackTime(var T: DateTime;var P: Longint);
procedure GetIntVec(IntNo:Byte;var Vector:Pointer);
procedure SetIntVec(IntNo: Byte; Vector: Pointer);
function FSearch(Path: PathStr; DirList: String):
PathStr;
function FExpand(Path: PathStr): PathStr;
procedure FSplit(Path: PathStr; var Dir: DirStr;
var Name: NameStr; var Ext: ExtStr);
function EnvCount: Integer;
function EnvStr(Index: Integer): String;
function GetEnv(EnvVar: String): String;
procedure SwapVectors;
procedure Keep(ExitCode: Word);
procedure Exec(Path: PathStr; ComLine: ComStr);
function DosExitCode: Word;
uses Dos,crt;
var DirInfo : SearchRec;
Ver : Word;
S : PathStr;
Języki programowania -Pascal Strona 74
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
begin
FindFirst('*.pas', AnyFile, DirInfo);
while DosError = 0 do
begin
Writeln(DirInfo.Name); FindNext(DirInfo);
end;
Writeln(DiskSize(0) div 1024, ' Kbytes capacity');
Writeln(DiskFree(0) div 1024, ' Kbytes free ');
Ver := DosVersion;
Writeln('System DOS :', Lo(Ver), '.',Hi(Ver));
S := FSearch('TURBO.EXE',GetEnv('PATH'));
if S = '' then WriteLn('TURBO.EXE not found')
else WriteLn('Found as ',FExpand(S));
readkey;
end.
uses Dos,Crt;
function LeadingZero(w : Word) : String;
var s : String;
begin
Str(w:0,s);
if Length(s) = 1 then s := '0' + s;
LeadingZero := s;
end;
var h, m, s, hund : Word;
poz_x,poz_y:byte;
begin
poz_x:=WhereX; poz_y:=WhereY;
repeat
GetTime(h,m,s,hund); gotoxy(poz_x,poz_y);
Write(LeadingZero(h),':',LeadingZero(m),':',
LeadingZero(s));
until keypressed;
end.
11.4 Moduł tworzone przez użytkownika
Unit Nazwa;
Interface
{ Deklaracje publiczne}
Implementation
{ Deklaracje prywatne I definicje podprogramów}
Języki programowania -Pascal Strona 75
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Begin { może być pominięty gdy brak}
{instrikcje inicjalizacyjne modułu}
End.
unit test;
Interface
function Czekaj(znaki:string):Byte;
Implementation
Uses crt;
const KlawiszESC=#27;
function czekaj;
var z:char;
w:byte;
Begin
{czyszczenie bufora klawiatury}
while keypressed do readkey;
repeat
z:=readkey;
if z=KlawiszESC then break;
w:=pos(z,znaki);
until w>0;
Czekaj :=w;
End;
BEGIN
END.
Program Test_modulu;
uses test;
const s:string='TtNn';
Begin
write('Twoj wybor :',s[czekaj(s)]);
End.
Języki programowania -Pascal Strona 76
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
12 Dynamiczne struktury danych
12.0.1 Pojęcie wskaz
nika
Wskaz
nik do danych to dynamiczny adres pownego obszaru pamięci.
Położenie tego obszaru może być, i bardzo często jest, różne podczas
kolejnych uruchomiań programu.
Type
Pdane=^Dane;
Dane =Integer;
Var p:PDane;
d:Dane;
Begin
d:=76;
p:=@d;
writeln(longint(p),' zawiera ',p^);
inc(p^);
writeln('d zawiera ',d);
new(p);
p^:=123;
writeln(longint(p),' zawiera ',p^);
writeln('d zawiera ',d);
Dispose(p);
End.
Var p:Pointer;
Begin
d:=76;
p:=@d;
writeln(longint(p),' zawiera ',PDane( p)^);
new(PDane(p));
PDane(p)^:=123;
writeln(longint(p),' zawiera ',PDane( p)^);
writeln('d zawiera ',d);
End.
Języki programowania -Pascal Strona 77
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
12.1 Tablica wskazników
Pstring=^String[80];
PTablica=Array [1..N] of PString;
PTab=^Ptrablica;
Var t:PTab;
Język Turbo Pascal nie umożliwia deklaracji tablic w pełni dynamicznych.
Powyższe konstrukcje tyklo trochę przyblizają to rozwiązanie.
begin
new(t);
K:=N div 2;
For i:=1 TO K DO
begin
new(T^[i]);
str(i,T^[i]^);
end;
...
For i:=1 TO N DO
begin
if T^[i]^ <>Nil then
writeln(T^[i]^)
else writeln;
end;
...
end.
·ð Dostp do elementów w takiej tablicy jest zbliżony do zwykÅ‚ej tablicy.
·ð dane tablicy i wskaz
niki są przechwywane na stercie  zwiększa to
ilość dostępnej pamięci dla programu
·ð Nie wszystkie wiersze muszÄ… zawierać dane  usuniÄ™cie wiersza to
zwolnmienie
·ð Zakres nie oznacza deklaracji peÅ‚nej tablicy 2 wymiarowej
·ð Z góry ograniczona ilość wierszy
·ð Utrudniopne dodanie wiersza ( z wyjÄ…tkiem koÅ„ca)
·ð UsuniÄ™cia mogÄ… powodować powstanie  rzadkich tablic
Języki programowania -Pascal Strona 78
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
12.2 Stos
12.2.1 Struktura stosu
Stos danych w pewnym uproszczeniu można porównać do stosu talerzy na
stole. Dostęp mamy tylko do jednego talerza znajdującego się na szczycie
stosu. Aby sięgnąć do kolejnych talerzy musimy zdjąć ze stosu te, które są
położone wyżej. Element stosu może wyglądać następująco:
PElement=^Element;
Element=record
Data : Dane;
Next : PElement;
end;
12.2.2
12.2.3 Na stos
Procedure na_stos(e:Dane;var top:PElement);
var Pom: Pelement;
begin
pom:=Top;
New(Top);
top^.next:=pom;
Top^.Data:=e;
end;
Języki programowania -Pascal Strona 79
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
12.2.4 Ze stosu
function ze_stosu(var e:Dane;var top:PElement):
boolean;
var Pom: Pelement;
begin
if (top<>nil)then
begin
ze_stosu:=True;
e:=Top^.Data;
Pom:=Top;
Top:=Top^.next;
Dispose(Pom);
end
else ze_stosu:=False;
end;
var i : Dane;
s,x : PElement;
BEGIN
s:=nil;
for i:=1 to 10 do
begin
na_stos(i,s);
write(s^.Data:4);
end;
writeln;
while (Ze_stosu(i,s)) do
write(i:4)
END.
12.2.5 Zastosowanie stosu
·ð Odwracanie ciÄ…gu elementów
·ð Zamiana wyrażenia na notacjÄ™ polskÄ…
·ð Obliczenia wartoÅ›ci wyrażeÅ„ w notacji polskiej
Języki programowania -Pascal Strona 80
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
12.3 Listy 1 i 2 kierunkowe
12.3.1 Struktura listy 1 kierunkowej
Struktura danych listy jednokierunkowej jest tożsama ze strukturą stosu. Tu
także mamy powiązane za pomocą jednego wskaz
nika dane.
Plista=^Lista;
Lista= record
d : Dane;
next : Plista;
end;
Lista od stosu będzie odróżniać sposobem dostępu do danych. Zamiast
prostych procedur operujÄ…cych na pierwszym elemencie, jak to
było we wcześniejszym przypadku, będziemy mieli pełna kontrolę
nad poszczególnymi częściami składowymi listy. Niestety te dużo
większe możliwości stawiają przed programistą dużo większe
wymagania. Trzeba pamiętać, że operacje na liście wiążą się z
bezpośrednim dostępem do pamięci komputera. Dobrze jest więc i
w tym przypadku ograniczyć się do operowania na elementach
listy za pośrednictwem odpowiednich procedur. A
atwiej przecież
dokładnie przeanalizować krótki kod z
ródłowy a następnie z
niego umiejętnie korzystać.
12.3.2 Podstawowe operacje na liście
12.3.2.1 Dodanie elementu
procedure dolisty(var p,k:Plista;d:dane);
var pom:Plista;
Begin
new(pom);
pom^.d:=d;
pom^.next:=nil;
if k<>nil then
k^.next:=pom
else p:=pom;
k:=pom;
end;
12.3.2.2 Wykonanie operacji na każdym elemancie listy
Języki programowania -Pascal Strona 81
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
procedure PiszWszystko(p:Plista);
Begin
Writeln;
while(p<>Nil)do
begin
write(p^.D:3);
P:=P^.Next;
end;
Bardziej uniwersalny sposób:
Type ProcDane=Procedure(x:Dane);
procedure piszDane(x:Dane);far;
begin
write(x:4)
end;
procedure DlaKazdego(p:Plista;proc:ProcDane);
Begin
Writeln;
while(p<>Nil)do
begin
proc(p^.D);
P:=P^.Next;
end;
End;
Wywołanie procedury
dlaKazdego(p,PiszDane);
12.3.2.3 Szukanie elementu na liście
Funkcja szukająca elementu na liście powinna zwracać jako wynik wskaz
nik
na element, jeśli istnieje, bądz
nil w przeciwnym przypadku. W
przypadku listy 1 kierunkowej można pokusić się o zwracanie
poprzedniego wskaz
nika na liście  użyteczne zarówno przy
dodawaniu jak i usuwaniu.
function Find(el:Dane;pocz:Plista;var B:PLista):
PLista;
Języki programowania -Pascal Strona 82
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
begin
if pocz^.d=el then
begin B:=Nil; find:=pocz; end
else
begin
while (pocz^.next<>nil)and
(pocz^.Next^.d<>el) do
pocz:=pocz^.Next;
B:=pocz;
Find:=pocz^.Next;
end
end;
12.3.2.4 Usunięcie elementu
procedure usun(var p:PLista;el:dane);
var b,Lpom:Plista;
begin
if p<>nil then
begin
Lpom:=find(el,p,b);
if B =nil then {usunąć pierwszy element}
begin
P:=P^.Next; Dispose(Lpom);
end
else if Lpom <>nil then
begin
b^.next:=Lpom^.next;
Dispose(Lpom);
end
else
writeln('Element nie należy do listy');
end
else writeln('Lista jest pusta');
end;
Języki programowania -Pascal Strona 83
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
12.3.2.5 Odwracanie listy
function Odwroc(var pocz:Plista):Plista;
var lPtr,Lpom:PLista; { Odwraca listÄ™ }
begin { bez tworzenia nowych elementów }
lPtr:=pocz;
pocz:=nil;
while lPtr <> nil do
begin
lPom:=lPtr^.Next;
lPtr^.Next:=pocz;
pocz:=lPtr;
lPtr:=lPom;
end;
Odwroc:=pocz;
end;
12.3.2.6 Zmiana kolejności danych, sortowanie listy
W powyższym przykładzie zastosowano dodawanie na koniec listy. Równie
łatwo można napisać procedurę, która już na etapie tworzenia
listy ją posortuje. Duże podobieństwo listy do tablicy
umożliwia implementacje niektórych algorytmów sortowania
tablic również dla listy. Zamianę elementów na liście można
zrealizować dwojako: poprzez zamianę danych-jak to było w
tablicach, bÄ…dz
dużo lepiej poprzez zamianę wskaz
ników.
procedure zamiana(var pocz, p1,p2:Plista);
var pop1,pop2,pom:Plista;
begin
pop1:=Nil; pop2:=Nil;
if p1 <>Nil then Find(p1^.D,pocz,pop1) else exit;
if p2<>NIl then Find(p2^.D,pocz,pop2) else exit;
if pop1=Nil then {czyli p1 = pocz}
pocz:=p2 else pop1^.Next:=p2;
if p1 = Pocz then {p2 = pocz}
pocz:=p2 else pop2^.Next:=p1;
pom:=p2^.Next;
p2^.Next:=p1^.Next;
p1^.Next:=pom;
end;
Języki programowania -Pascal Strona 84
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
12.3.3 Struktura listy 2 kierunkowej
Lista dwukierunkowa to tak jakby dwie listy jednokierunkowe, gdzie dane sÄ…
wspólne. W poprzedniej liście łatwe było poruszanie się po
elementach listy tylko w jednym kierunku. Aby dostać się do
elementy poprzedzającego bieżący trzeba przeglądać całą listę od
początku. Tej niedogodności tu już nie będzie.
lista2=^skladnik_listy2;
skladnik_listy2 =record
wsk1:lista2;{wiersz
porzedni }
s:Wiersz;
wsk2:lista2;{następny}
end;
12.3.4 Dodawanie do listy
procedure do_listy2(var element:Wiersz;var
pocz,kon:lista2);
var pop_skl,nas_skl:lista2;
podstaw:boolean;
begin
if kon<>nil then
begin
podstaw:=false;pop_skl:=kon;nas_skl:=kon^.ws
k2; end
else
begin podstaw:=true;pop_skl:=nil;nas_skl:=nil end;
new(kon);
with kon^ do
begin
wsk1:=pop_skl;
s:=element;
wsk2:=nas_skl;
end;
if pop_skl<>nil then pop_skl^.wsk2:=kon;
if nas_skl<>nil then nas_skl^.wsk1:=kon;
if podstaw then pocz:=kon;
end;
Języki programowania -Pascal Strona 85
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Function szukaj(w:wiersz;p:Lista2):Lista2;
Begin
while p<>nil do begin
if p^.s=w then break;
p:= p^.wsk2;
end;
szukaj:=p;
End;
Procedure Usun(w:Wiersz;var p,k:Lista2);
var ew:Lista2;
Begin
ew:=szukaj(w,p);
if ew=nil then exit;
if ew=p then p:=p^.wsk2
else ew^.wsk1^.wsk2:=ew^.wsk2;
if ew=k then k:=k^.wsk1
else ew^.wsk2^.wsk1:=ew^.wsk1;
Dispose(ew);
End;
procedure Zamien(x,y:Wiersz;var p,k:Lista2);
var xw,yw,x2,x1,y2,y1:Lista2;
Begin
xw:=szukaj(x,p); if xw=Nil then exit;
yw:=szukaj(y,p); if yw=Nil then exit;
x1:=xw^.wsk1; x2:=xw^.wsk2;
y1:=yw^.wsk1; y2:=yw^.wsk2;
{-->}
if x1=Nil then p:=yw else x1^.wsk2:=yw;
yw^.wsk2:=x2;
if y1=Nil then p:=xw else y1^.wsk2:=xw;
xw^.wsk2:=y2;
{<--}
if y2=Nil then k:=xw else y2^.wsk1:=xw;
xw^.wsk1:=y1;
if x2=Nil then k:=yw else x2^.wsk1:=yw;
yw^.wsk1:=x1;
end;
Języki programowania -Pascal Strona 86
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
12.3.5 Zastosowanie list
Listy mają podobne zastosowania, jak tablice. W odróżnieniu od tablic nie
jesteśmy tu ograniczeni jakąś z góry narzuconą maksymalną
ilością elementów. Tych elementów może być zarówno kilka jak i
kilkaset. Oczywiście ograniczeniem jest tu dostępna pomięć
operacyjna.
Języki programowania -Pascal Strona 87
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
12.4 Drzewa binarne
Inna strukturÄ… rekurencyjnÄ… sÄ… drzewa. NajciekawszÄ… wersjÄ… jest drzewo
binarne uporządkowane. Mogą one być bardzo użyteczne przy
tworzeniu struktur słownikowych. Poszukiwanie danych może być
tu dużo prostrze niż na zwykłej liście.
Terminologia zaczerpmięta z biologi : Drzewo, Korzeń, gałąz
, liście ,
poddrzewo.
Ze względu na wyróżnienie oddrzew najbardziej natyralną metodą
postepowania z drzewami jest rekurencja.
5
2 7
1 3 6 8
1 2 3 5 6 7 8
12.4.1 Strukrura danych
Typ danych właściwie ten sam co i w liscie 2 kierunkowej.
PDrzewo=^Drzewo;
drzewo=record
L,P : PDrzewo;
D : Dane;
end;
Języki programowania -Pascal Strona 88
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
12.4.2 Tworzenie Drzewa
Dowdanie nowego elementu do drzewa.
5
2 7
1 3 6 8
4
procedure dodaj (var d:Pdrzewo;x:dane);
begin
if d = Nil then { miejsce dodania}
begin
new(d);
d^.L:=Nil;
d^.P:=Nil;
d^.D:=x;
end
else
if d^.D > x then
dodaj(d^.L,x)
else
dodaj(d^.P,x);
end;
procedure pisz(d:PDrzewo;poz:byte);
begin
if D<>Nil then
begin
pisz(d^.L,poz+1);
writeln(d^.D:poz);
pisz(d^.P,poz+1)
end
end;
Języki programowania -Pascal Strona 89
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
12.4.3 Szukanie elementu
function szukaj(d:PDrzewo;x:Dane):PDrzewo;
Begin
if d = nil then begin
write('(Brak) ',x);
Szukaj:=Nil
end
else
if d^.D = x then begin
write(d^.D,' (Znaleziony)');
szukaj:=D;
end
else if d^.D > x then begin
write(D^.D,'->');
szukaj:=szukaj(D^.L,x);
end
else{ d^.D < x } begin
write(D^.D,'->');
szukaj:=szukaj(D^.P,x);
end
end;
Języki programowania -Pascal Strona 90
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
12.4.4 Usuniecie liścia i węzła
5
2 7
1 3 6 8
4
procedure usun(var D:PDrzewo;x:Dane);
var S,nk,pnk:PDrzewo;
begin
if d = Nil then exit;
if d^.d < x then usun(d^.P,x)
else if d^.d > x then usun(d^.L,x)
else {d^.d = x}
begin
s:=d;
if d^.P = nil then d:=d^.L
else if d^.L = nil then d:=d^.P
else{ obie gałęzie są niepuste}
begin
nk:=D^.L;pnk:=D;
while(nk^.P<>Nil) do
begin pnk:=nk; nk:=nk^.P; end;
if pnk<>D then begin
pnk^.P:=nk^.L; nk^.L:=D^.L;
end;
nk^.P:=D^.P; d:=nk;
end;
Dispose(s);
end;
end;
Języki programowania -Pascal Strona 91
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
12.4.5 Równoważenie Drzewa
5
2
7
8
1 3
4
6
Procedure balance(var d:PDrzewo);
var ileP,ileL:Integer;
Begin
if d = Nil then exit;
ileP:=Ilosc(D^.P);IleL:=Ilosc(D^.L);
Repeat
if ileP-ileL>1 then
begin
dec(ileP);inc(ileL);
zPrawoNaLewo(d);
end
else
if ileL-ileP>1 then
begin
dec(ileL);inc(ileP);
ZlewoNaPrawo(d);
end
else Break;
Until False;
Balance(D^.L);Balance(d^.P);
End;
Function Ilosc(d:PDrzewo):Word;
Begin
Języki programowania -Pascal Strona 92
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
if d = nil then Ilosc:=0
else
Ilosc:=Ilosc(d^.L)+Ilosc(d^.P)+1;
end;
procedure ZlewoNaPrawo(var d:PDrzewo);
var L,pl:PDrzewo;
begin
if d=Nil then exit;
L:=D^.L;pl:=D;
while L^.P<>nil do begin
pl:=L;L:=L^.P;
end;
if pl<>D then
begin
pl^.P:=L^.L; L^.L:=D^.L;
end;
L^.P:=D; D^.L:=Nil;
D:=L;
end;
procedure ZPrawoNaLewo(var d:PDrzewo);
var P,pp:PDrzewo;
begin
if d=Nil then exit;
P:=D^.P;pp:=D;
while P^.L<>nil do begin
pp:=P;P:=P^.L;
end;
if pp<>D then
begin
pp^.L:=P^.P; P^.P:=D^.P;
end;
P^.L:=D; D^.P:=Nil;
D:=P;
end;
Języki programowania -Pascal Strona 93
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
13 Grafika w Turbo Pascalu
13.1 Programowanie w trybie graficznym
Tryb tekstowy a tryb graficzny
Tryb tekstowy (znakowy):
80 kolumn 25 wierszy
(40x25, 80x40, 80x50, 160x50)
Tryb graficzny (piksel)
640x480(standard VGA) przy 16 Kolorach
320x200, 800x600, 1024x768,1200x1024, 1600x1200
Ilość kolorów: 16(4 b), 256(8 b), 65 536(16Kb) ,
16 777 216(24Mb), 42 949 672 96(32Mb)
13.1.1 Wprowadzenie do pracy w trybie graficznym
Program garficzny;
Uses Graph,Crt;
const PathToDriver:String='C:\Programy\TP7\BGI';
function TrybGraficzny:boolean;
var dr,tryb:Integer;
begin
dr:=Detect;
InitGraph(dr,tryb,PathToDriver);
TrybGraficzny:=GraphResult=GrOK;
end;
dr:=9; tryb:=2; {640x480x16}
Języki programowania -Pascal Strona 94
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Function InitVesa:Boolean;
var VESA16 : Integer;
tryb:Integer;
begin
Tryb:=0;
VESA16 := InstallUserDriver('VESA16', Nil);
InitGraph(Vesa16,Tryb,PathToDriver);
InitVesa:=GraphResult=GrOK;
end;
function TrybGraficzny:boolean;
var dr,tryb:Integer;
begin
if initvesa then TrybGraficzny:=True
else
begin
dr:=Detect; { dr:=9; tryb:=2;}
InitGraph(dr,tryb,PathToDriver);
TrybGraficzny:=GraphResult=GrOK;
end;
end;
function Int2Str(x:Integer):String;
var s:string;
Begin
Str(x,s); Int2Str:=s;
end;
BEGIN
if not trybGraficzny then exit;
Rectangle(0,0,GetmaxX,GetMaxY);
moveto(getmaxx div 2,getmaxy div 2);
SetTextJustify(CenterText, CenterText);
OutText(Int2Str(getmaxX+1)+'x'+Int2Str(getmaxY+1)+
'x'+Int2Str(getmaxColor+1));
PutPixel(10,10,Yellow);
SetAspectRatio(getmaxy, getmaxx);
Circle(getmaxx div 2,getmaxy div 2,getmaxx div 2);
Readkey;
closeGraph;
END.
Języki programowania -Pascal Strona 95
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
13.2 Narzędzia graficzne w Turbo Pascalu
13.2.1 Moduł Graph
Procedury i funkcje modułu GRAPH
P. Arc (X,Y; Integer; StAngle, EndAngle, Radius; Word); *
P. Bar(x1, y1, x2, y2: Integer); *
P. Bar3D(x1, y1, x2, y2: Integer; Depth: Word; Top: Boolean); *
P. Circle(X,Y: Integer; Radius: Word); *
P. ClearDevice; *
P. ClearViewPort; *
P. CloseGraph; *
P. DetectGraph(var GraphDriver, GraphMode: Integer); *
P. DrawPoly(NumPoints: Word; var PolyPoints); *
P. Ellipse(X, Y: Integer; StAngle, EndAngle: Word; XRadius, YRadius:Word); *
P. FillEllipse(X, Y: Integer; XRadius, YRadius: Word) *
P. FillPoly(NumPoints: Word; var PolyPoints); *
P. FloodFill(X, Y: Integer; Border: Word); *
P. GetArcCoords(var ArcCoords: _ArcCoordsType_);
P. GetAspectRatio(var Xasp, Yasp: Word);
F. GetBkColor: Word; *
F. GetColor: Word; *
F. GetDefaultPalette(var Palette: PaletteType);
F. GetDriverName: string; *
P. GetFillPattern(var FillPattern: FillPatternType); *
P. GetFillSettings(var FillInfo: FillSettingsType); *
F. GetGraphMode: Integer; *
P. GetImage(x1, y1, x2, y2: Integer; var BitMap);
P. GetLineSettings(var LineInfo: LineSettingsType); *
F. GetMaxColor: Word; *
F. GetMaxMode: Integer; *
F. GetMaxX: Integer; *
F. GetMaxY: Integer; *
F. GetModeName(ModeNumber: Integer): string; *
P. GetModeRange(GraphDriver:Integer; var LoMode, HiMode:Integer);
P. GetPalette(var Palette: PaletteType);
F. GetPaletteSize: Integer;
F. GetPixel(X,Y: Integer): Word; *
P. GetTextSettings(var TextInfo: TextSettingsType); *
P. GetViewSettings(var ViewPort: ViewPortType);
F. GetX: Integer; *
F. GetY: Integer; *
P. GraphDefaults;
F. GraphErrorMsg(ErrorCode: Integer): string;
F. GraphResult: Integer; *
F. ImageSize(x1, y1, x2, y2: Integer): Word;
P. InitGraph(var GraphDriver:Integer; var GraphMode: Integer; PathToDriver: string); *
F. InstallUserDriver(Name: string; AutoDetectPtr: pointer): integer;
F. InstallUserFont(FontFileName: string ): Integer;
P. Line(x1, y1, x2, y2: Integer); *
Języki programowania -Pascal Strona 96
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
P. LineRel(Dx, Dy: Integer); *
P. LineTo(X, Y: Integer); *
P. MoveRel(Dx, Dy: Integer); *
P. MoveTo(X, Y: Integer); *
P. OutText(TextString: string); *
P. OutTextXY(X,Y: Integer; TextString: string); *
P. PieSlice(X, Y: Integer; StAngle, EndAngle, Radius: Word); *
P. PutImage(X, Y: Integer; var BitMap; BitBlt: Word);
P. PutPixel(X, Y: Integer; Pixel: Word); *
P. Rectangle(x1, y1, x2, y2: Integer); *
F. RegisterBGIdriver(driver: pointer): Integer;
F. RegisterBGIfont(Font: pointer): Integer;
P. RestoreCrtMode; *
P. Sector(x, y: Integer; StAngle,EndAngle, XRadius, YRadius: Word);
P. SetActivePage(Page: Word); *
P. SetAllPalette(var Palette);
F. SetAspectRatio(Xasp, Yasp: Word): Word;
P. SetBkColor(ColorNum: Word); *
P. SetColor(Color: Word); *
P. SetFillPattern(Pattern: FillPatternType; Color: Word); *
P. SetFillStyle(Pattern: Word; Color: Word); *
P. SetGraphBufSize(BufSize: Word);
P. SetGraphMode(Mode: Integer);
P. SetLineStyle(LineStyle: Word; Pattern: Word; Thickness: Word); *
P. SetPalette(ColorNum: Word; Color: Shortint);
P. SetRGBPalette(ColorNum, RedValue, GreenValue, BlueValue:Integer);
P. SetRGBPalette(ColorNum, RedValue, GreenValue, BlueValue:Integer);
P. SetTextJustify(Horiz, Vert: Word); *
P. SetTextStyle(Font, Direction: Word; CharSize: Word); *
P. SetUserCharSize(MultX, DivX, MultY, DivY: Word);
P. SetViewPort(x1, y1, x2, y2: Integer; Clip: Boolean); *
P. SetVisualPage(Page: Word); *
P. SetWriteMode(WriteMode: Integer); *
F. TextHeight(TextString: string): Word; *
F. TextWidth(TextString: string): Word; *
Języki programowania -Pascal Strona 97
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
13.2.1.1 Stałe i typy zdefiniowane w modułe GRAPH
Constants :
Colors for the 8514:
Bar3D Constants:
Dark Colors:
TopOn True
EGABlack 0
TopOff False
EGABlue 1
EGAGreen 2
Clipping Constants:
EGACyan 3
ClipOn True
EGARed 4
ClipOff False
EGAMagenta 5
EGABrown 20
EGALightgray 7
BitBlt Operators:
Constant | Value| Meaning Light Colors :
---------------------------------------
EGADarkgray 56
NormalPut | 0 | MOV
EGALightblue 57
CopyPut | 0 | MOV
XORPut | 1 | XOR
EGALightgreen 58
OrPut | 2 | OR
EGALightcyan 59
AndPut | 3 | AND
EGALightred 60
NotPut | 4 | NOT
EGALightmagenta 61
EGAYellow 62
Color Constants:
EGAWhite 63
Dark Colors:(Foreground & Background)
Black 0
Blue 1
Green 2
Cyan 3
Red 4
Magenta 5
Brown 6
LightGray 7
Light Colors:(Foreground)
DarkGray 8
LightBlue 9
LightGreen 10
LightCyan 11
LightRed 12
LightMagenta 13
Yellow 14
White 15
For flashing (blinking) text
foreground, Blink= 128.
SolidFill | 1 | Uses draw color
Fill Pattern Constants
LineFill | 2 | --- fill
Constant | Value| Meaning
LtSlashFill | 3 | /// fill
-------------------------------------------------
SlashFill | 4 | /// thick fill
EmptyFill | 0 | Uses background color
Języki programowania -Pascal Strona 98
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
BkSlashFill | 5 | \thick fill
Justification Constants
LtBkSlashFill | 6 | \fill
HatchFill | 7 | Light hatch fill
Horizontal Constant | Value
XHatchFill | 8 | Heavy cross hatch
--------------------------
InterleaveFill | 9 | Interleaving line
LeftText | 0
WideDotFill | 10 | Widely spaced dot
CenterText | 1
CloseDotFill | 11 | Closely spaced dot
RightText | 2
UserFill | 12 | User-defined fill
Vertical Constant | Value
Graphics Drivers
-------------------------------
Constant | Value/Comment BottomText | 0
--------------ì------------------------ CenterText | 1
CurrentDriver | -128/For GetModeRange TopText | 2
Detect | 0/Requests autodetection
CGA | 1
Line-Style and Width Constants
MCGA | 2
EGA | 3
Line Styles:
EGA64 | 4
SolidLn 0
EGAMono | 5
DottedLn 1
IBM8514 | 6
CenterLn 2
HercMono | 7
DashedLn 3
ATT400 | 8
UserBitLn 4 (User-defined line style)
VGA | 9
PC3270 | 10
Line Widths:
NormWidth 1
Graphics Modes for Each Driver
ThickWidth 3
Constant | Value | Meaning Constant | Value | Meaning
Text-Style Constants
-----------ì-------ì----------- -----------ì-------ì------------
CGAC0 | 0 |320 x 200 EGALo | 0 | 640 x 200
CGAC | 1 | 320 x 200 EGAHi | 1 | 640 x 350 Constant |Value| Meaning
CGAC2 | 2 | 320 x 200 | |
--------------ì-------ì-------------------
CGAC3 | 3 | 320 x 200 EGA64Lo | 0 | 640 x 200
DefaultFont | 0 | 8x8 bit mapped font
CGAHi | 4 | 640 x 200 EGA64Hi | 1 | 640 x 350
TriplexFont | 1 | Stroked font
| | | |
SmallFont | 2 | Stroked font
MCGAC0 | 0 | 320 x 200 ATT400C0 | 0 | 320 x 200
SansSerifFont | 3 | Stroked font
MCGAC1 | 1 | 320 x 200 ATT400C1 | 1 | 320 x 200
GothicFont | 4 | Stroked font
MCGAC2 | 2 | 320 x 200 ATT400C2 | 2 | 320 x 200
HorizDir | 0 | Orient left to right
MCGAC3 | 3 | 320 x 200 ATT400C3 | 3 | 320 x 200
VertDir | 1 | Orient bottom to top
MCGAMed | 4 | 640 x 200 ATT400Med | 4 | 640 x 200
UserCharSize | 0 | User-defined character size
MCGAHi | 5 | 640 x 480 ATT400Hi | 5 | 640 x 400
| | | |
EGAMonoHi | 3 | 640 x 350 IBM8514Lo | 0 | 640 x 480
HercMonoHi | 0 | 720 x 348 IBM8514Hi | 1 |1024x768
| | | | 13.2.1.2 Types :
VGALo | 0 | 640 x 200 PC3270Hi | 0 | 720 x 350
ArcCoordsType
VGAMed | 1 | 640 x 350 VGAHi | 2 | 640 x 480
FillPatternType
FillSettingsType
Graphics Memory Pointers
LineSettingsType
PaletteType
PointType
TextSettingsType
ViewPort
Języki programowania -Pascal Strona 99
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
procedure StatusLine(Msg : string); WriteOut('GetMaxColor : '+Int2Str
var TH:word; (GetMaxColor));
begin WriteOut('Current color : '+Int2Str
TH:= TextHeight('M'); (GetColor));
SetViewPort(0, 0, MaxX, MaxY, ClipOn); WaitToGo;
SetColor(MaxColor); end; { ReportStatus }
SetTextStyle(DefaultFont, HorizDir, 1); procedure WriteOut(S : string);
SetTextJustify(CenterText, TopText); var x:integer;
SetLineStyle(SolidLn, 0, NormWidth); begin
SetFillStyle(EmptyFill, 0); x:=Getx; OutText( S);
Bar(0, MaxY-( TH+4), MaxX, MaxY); Moveto(x,GetY+ TextHeight('M')+2);
Rectangle(0, MaxY-( TH+4), MaxX, MaxY); end; { WriteOut }
OutTextXY(MaxX div 2, MaxY-(TextHeight('M') procedure WaitToGo;
+2), Msg); const Esc = #27; var Ch : char;
SetViewPort(1, TH+5, MaxX-1, MaxY-TH+5), begin
ClipOn); Ch := ReadKey;
end; { StatusLine } if ch = #0 then ch := readkey;
procedure ReportStatus; if Ch = Esc then Halt(0)
var else ClearDevice;
ViewInfo : ViewPortType; end; { WaitToGo }
LineInfo : LineSettingsType; function Int2Str(L : LongInt) : string;
FillInfo : FillSettingsType; var S : string;
TextInfo : TextSettingsType; begin
Palette : PaletteType; Str(L, S); Int2Str := S;
DriverStr , ModeStr : string; end; { Int2Str }
begin procedure DrawBorder;
DriveRStr := GetDriverName; var ViewPort : ViewPortType;
ModeStr := GetModeName(GetGraphMode); begin
GetViewSettings(ViewInfo); SetColor(MaxColor);
GetLineSettings(LineInfo); SetLineStyle(SolidLn, 0, NormWidth);
GetFillSettings(FillInfo); GetViewSettings(ViewPort);
GetTextSettings(TextInfo); with ViewPort do
GetPalette(Palette); Rectangle(0, 0, x2-x1, y2-y1);
MainWindow('Informacje '); end; { DrawBorder }
moveto(10,10); procedure MainWindow(Header : string);
SetTextJustify(LeftText, TopText); begin
WriteOut('Graphics device : '+DriverStr); SetColor(MaxColor); ClearDevice;
WriteOut('Graphics mode : '+ModeStr); SetTextStyle(DefaultFont, HorizDir, 1);
WriteOut('Screen resolution : (0, 0,  Int2Str SetTextJustify(CenterText, TopText);
(GetMaxX)+', '+Int2Str(GetMaxY)+')'); SetViewPort(0, 0, MaxX, MaxY, ClipOn);
with ViewInfo do begin OutTextXY(MaxX div 2, 2, Header);
WriteOut('Current view port : (' Int2Str(x1)+', SetViewPort(0, TextHeight('M')+4, MaxX,
'+Int2Str(y1)+', '+Int2Str(x2)+', ' Int2Str(y2)+')'); MaxY-(TextHeight('M')+4), ClipOn);
if ClipOn then WriteOut('Clipping : ON') DrawBorder;
else WriteOut('Clipping : OFF'); SetViewPort(1, TextHeight('M')+5, MaxX-1,
end; MaxY-(TextHeight('M')+5), ClipOn);
WriteOut('Current position : ('+Int2Str(GetX)+', end; { MainWindow }
'+Int2Str(GetY)+')'); Procedure DemoPutPixel;
WriteOut('Palette entries : '+Int2Str(Palette.Size)); Begin
MainWindow('PutPixel');
Języki programowania -Pascal Strona 100
____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
repeat PutPixel(random(GetMaxx),Random begin
(GetMaxY),Random(getMaxColor)); Bar(X, Y, X+W, Y+H);
until keypressed; Rectangle(X, Y, X+W, Y+H);
waittogo; end; { DrawBox }
end; Procedure DrawFigura(X, Y,W,H : word);
Procedure DemoLines; begin
var x1,x2,y1,y2:Word; Arc(x+W div 2,y+H div 2,0,180,W div 2);
Begin Moveto(x ,y+w div 2); Lineto(x,y+H);
MainWindow('Linie'); LineTo(x+W,y+H); LineTo(x+w,y+w div 2);
repeat FloodFill(x+W div 2,y+H div 2,GetColor);
x1:=random(GetmaxX); x2:=random(GetmaxX); end;
y1:=random(GetmaxY); y2:=random(GetmaxY); procedure FillStylePlay;
setcolor(Yellow); var
Rectangle(x1,y1,x2,y2); S,W,H,X,Y,I,J : word;
setcolor(White); delay(100); ViewInfo : ViewPortType;
Line(x1,y1,x1,y2); Line(x1,y2,x2,y2); begin
Line(x2,y2,x2,y1); Line(x2,y1,x1,y1); MainWindow('Pre-defined fill styles');
SetColor(Blue); delay(100); GetViewSettings(ViewInfo);
MoveTo(x1,y1); with ViewInfo do
Lineto(x1,y2); Lineto(x2,y2); begin
{ Lineto(x2,y1);} Lineto(x1,y1); W:= 2 * ((x2+1) div 13);
SetColor(Red); delay(100); H := 2 * ((y2-10) div 10);
MoveTo(x1,y1); end;
{LineRel(0,y2-y1); LineRel(x2-x1,0);} X := W div 2;
LineRel(x2-x1,y2-y1); Y := H div 2;
LineRel(0,y1-y2); LineRel(x1-x2,0); S := 0;
until keypressed; for J := 1 to 3 do
waittogo; begin
end; for I := 1 to 4 do
Procedure wieleokaty; begin
const MaxPts = 5; SetColor(Random(GetMaxColor)+1);
type SetFillStyle(S,Getcolor+1);
PolygonType = array[1..MaxPts] of PointType; if s mod 2 = 0 then DrawBox(X, Y,W,H)
var Poly : PolygonType; else DrawFigura(X, Y,W,H);
I, Color : word; OutTextXY(X+(W div 2), Y+H+4, Int2Str
begin (S));
MainWindow('Wilokaty'); Inc(S); Inc(X, (W div 2) * 3);
repeat end;
Color := Random(GetmaxColor)+1; X := W div 2;
SetFillStyle(Random(11)+1, Color); Inc(Y, (H div 2) * 3);
SetColor(Color); end;
for I := 1 to MaxPts do SetTextJustify(LeftText, TopText);
with Poly[I] do begin WaitToGo;
X := Random(MaxX); Y := Random(MaxY); end; { FillStylePlay }
end;
FillPoly(MaxPts, Poly);
until KeyPressed;
WaitToGo;
end; {Wieloaty }
procedure DrawBox(X, Y,W,H : word);