Budowa programu tworzonego w języku Pascal
Program pisany w języku Pascal składa się z dwóch części:
deklaracyjnej
wykonawczej
{część deklaracyjna}
BEGIN
{część wykonawcza}
END.
W części deklaracyjnej możemy zaimplementować:
Nazwę programu
Deklaracja modułów
Etykiety
Stałe
Typy danych
Zmienne
Procedury i funkcje
Zaś w części wykonawczej podajemy instrukcje, które nasz program będzie wykonywał w odpowiedniej kolejności.
{Początek części deklaracyjnej}
PROGRAM Nazwa_Programu; {Nagłówek programu}
USES {Deklaracja modułów}
LABEL
CONST
TYPE
VAR
PROCEDURE
FUNCTION
{Koniec części deklaracyjnej}
BEGIN
{Część wykonawcza programu}
END.
Każdy program musi zawierać słowo kluczowe program, BEGIN i END zakończone kropką, natomiast pozostałe elementy są opcjonalne.
Dlatego bardzo prosty program może mieć następującą formę:
{Legendarny program wypisujący na ekranie monitora słowa HALLO WORLD}
PROGRAM pierwszy_program;
BEGIN
write(`HALLO WORLD! :)');
END.
Podstawowe konwencje obowiązujące w języku Pascal:
Po każdej instrukcji musi występować średnik ";", ale z małymi wyjątkami, którym między innymi jest słowo BEGIN po którym nic nie piszemy.
Kropkę zaś stawiamy po słowie END kończącym część wykonawczą.
Dowolny tekst ujęty w znaki {} lub (* *) traktowana jest jako komentarz - czyli jest ignorowany przez kompilator.
Pojedynczą linia będzie traktowana jako komentarz gdy na początku umieścimy znak //. Komentarze nie są wymagane, jednak poprawiają czytelność programu dlatego należy je stosować.
Identyfikator czyli nazwa typu, stałej, zmiennej, funkcji, procedury i programu musi zaczynać się od litery i nie może zawierać operatorów arytmetycznych i innych znaków specjalnych. Może zawierać litery, cyfry i znak "_". Małe i duże litery zarówno w nazwach jak i słowach kluczowych nie są rozróżniane.
Składnia języka Pascal nie wymusza podziału programu na wiersze (oprócz deklaracji zmiennych łańcuchowych) i cały program może być dowolnie podzielony na linie. Istotne jest tylko, aby poszczególne słowa kluczowe i identyfikatory były oddzielone separatorem (dowolna ilość spacji lub znaku końca wiersza, średnik. nawias,+, -, :, =, >, <). Ponadto wiersz programu nie może zawierać więcej niż 127 znaków.
Podczas wykonywania działań na zmiennych lub stałych należy uważać aby wszystkie elementy były zgodne z tym samym typem.
Opis elementów stanowiących szkielet programu:
W nagłówku programu podaje się zwykle jego nazwę.
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
Za pomocą deklaracji modułów (ang. USES) określa się moduły standardowe i moduły zdefiniowane przez użytkownika, np.
USES CRT,DOS;
Powyższa deklaracja dołącza dla naszego programu dwa standardowe moduły DOS i CRT.
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
Etykiety (ang. LABEL) powodują skok do określonej części programu - wywołujemy je słowem kluczowym GOTO, np.
LABEL skok_1,skok_2;
...
BEGIN
GOTO skok_1;
...
...{Jakieś funkcje czy procedury.}
...
skok_1: Writeln('Skok do etykiety skok_1');
skok_2: Writeln('Skok do etykiety skok_2');
END.
Powyższy przykład obrazuje skok do etykiety skok_1. Podczas tej operacji omijane są wszelkie instrukcje, procedury i funkcje znajdujące się w wykropkowanych miejscach.
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
Gdy w programie deklarujemy Stałe (ang. CONST), to przypisana im wartość nie może zostać zmieniona w dalszej części programu
CONST
identyfikator = wartość;
lub
identyfikator : type = wartość;
W drugiej wersji Type oznacza dowolny typ danych, wtedy wartość stałej przypisujemy zgodnie z typem.
Przykłady:
CONST MaxWysokosc = 100;
MaxPredkosc = 10.5;
lub
CONST MaxWysokosc : Integer = 100;
MaxPredkosc : Real = 10.5;
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
Zbiór wartości które może przyjmować zmienna nazywa się typem.
Typy dzielimy na standardowe (predefiniowane, nie wymagające opisu) i niestandardowe (definiowane przez programistę)
Deklaracje typów definiowanych przez programistę umieszczamy w sekcji Typy (ang. TYPE)
TYPE Dzien = (pon, wt, sr, czw, pt, sob, nie);
Numer = Integer;
---------------------------------------------------------------------------------------------------------------------------------------------------------------------
Każdą zmienną w programie zanim będziemy używać należy wcześniej zadeklarować w sekcji Zmienne (ang. VAR)
Deklaracja polega na określeniu nazwy zmiennej oraz jej typu.
VAR nazwa_zmiennej: typ_zmiennej;
Wartości deklarowanych zmiennych mogą być w programie modyfikowane (przypisanie nowej wartości) w przedziale akceptowanym przez typ zmiennej.
Dopuszczalne są także deklaracje kilku zmiennych jednego typu w pojedynczym wyrażeniu.
Sekcja VAR może występować wiele razy w programie.
Przykład:
VAR x, y, wynik: integer;
...
BEGIN
wynik:=0; {Wartość początkowa}
...
wynik:=10; {Wartość przypisana później}
END.
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
Procedura (ang. PROCEDURE) i funkcja (ang. FUNCTION) to wyodrębnione części programu, stanowiące pewną całość, posiadające jednoznaczną nazwę i ustalony sposób wymiany informacji z pozostałymi częściami programu. Procedury i funkcje są stosowane do wykonania czynności, które mogą być wykorzystane w różnych programach lub do wykonania czynności wielokrotnie powtarzanych przez dany program. Różnica pomiędzy procedurą a funkcją polega na sposobie przekazywania wartości. Zadaniem procedury jest wykonanie pewnej sekwencji czynności, polegających zwykle na obliczaniu jednej lub wielu wartości. Natomiast zadaniem funkcji jest obliczenie jednej wartości (typu prostego lub wskaźnikowego), która jako wynik wywołania funkcji zwracana jest za pomocą słowa kluczowego RESULT do bloku programu z którego nastąpiło wywołanie funkcji. Odmienne są też sposoby wywołania procedur i funkcji, np.
Definicja procedury:
PROCEDURE Nazwa_Procedury(lista_parametrów);
...Część_opisowa
BEGIN
...Ciąg_instrukcji
END;
W definicji procedury listę parametrów możemy pominąć.
Definicja funkcji:
FUNCTION Nazwa_Funkcji(lista_parametrów): Typ_wyniku;
...Część_opisowa
BEGIN
...Ciąg_instrukcji
Result := ...;
END;
W obu przypadkach lista parametrów zawiera deklarację parametrów, przy czym poszczególne deklaracje oddziela się średnikami. W przypadku funkcji w ciągu instrukcji musi wystąpić co najmniej jedna instrukcja przypisania w postaci:
Nazwa_Funkcji:=Wyrażenie
powodująca przypisanie wartości pod nazwę funkcji, przy czym co najmniej jedna z tych instrukcji musi być wykonana po wywołaniu funkcji. Typ wyniku funkcji jest określony za pomocą identyfikatora typu.
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
PASCAL - FUNKCJE STANDARDOWE
W Pascalu dostępny jest szereg tzw. "Funkcji standardowych" - czyli takich funkcji i procedur, które można spotkać we wszystkich kompilatorach.
Najważniejsze funkcje standardowe w Turbo Pascalu dające w wyniku wartość liczbową to:
ABS(x:real):real - Wartość bezwzględna z x
ARCTAN(x:real):real - Funkcja trygonometryczna ArcTg z x
COS(x:real):real - Funkcja trygonometryczna cosinus z x
EXP(x:real):real - e do potęgi x
FRAC(x:real):real - Część ułamkowa z liczby x
INT(x:real):real - Część całkowita z liczby x
LN(x:real):real - Logarytm naturalny z x
PI:real - Warość stałej pi
SIN(x:real):real - Funkcja trygonometryczna sinus z x
SQR(x:real):real - Kwadrat x
SQRT(x:real):real - Pierwiastek kwadratowy z x
ROUND(x:real):longint - Zaokrąglenie liczby x do wartości całkowitej
TRUNC(x:real):longint - Zaokrąglenie liczby x do wartości całkowitej przez odrzucenie części całkowitej
UWAGA: Wszystkie funkcje trygonometryczne w parametrze oczekują kąta podawanego w radianach!
A oto przykłady ich użycia:
y := 2*sin(3)+sin(2*x);
delta :=sqr(b)-4*a*c;
WRITE i WRITELN czyli pisanie po ekranie
Zwykle największą część każdego programu stanowi tzw. "Interface użytkownika". Mianem tym określa się fragment odpowiedzialny za komunikację z użytkownikiem - najczęściej przy użyciu monitora i klawiatury.
Funkcje WRITE i WRITELN należą do specjalnej klasy procedur, która ma zmienną liczbę parametrów. Procedury te pozwalają wypisać na ekranie wartość zmiennej, wyrażenia lub tekst.
Różnica pomiędzy obiema procedurami polega na tym, że WRITE po wypisaniu tekstu na ekranie pozostawia kursor w bieżącym wierszu za ostatnim wypisanym znakiem (chyba, że wiersz się skończy), zaś WRITELN ustawia kursor w pierwszej kolumnie następnego wiersza.
Parametrami procedur mogą być dowolne zmienne, stałe lub wyrażenia dające w wyniku wartość numeryczną, CHAR, logiczną lub łańcuchową (tekst) lub wartości powyzszych typów. Poszczególne argumenty oddziela się przecinkami. Wartości tekstowe należy zapisać w apostrofach pojedynczych.
Przykład:
WRITE('Podaj wartość x:',x);
WRITELN('x1=',(-b-sqrt(delta))/(2*a),' x2=',,(-b+sqrt(delta))/(2*a));
Szczególnym przypadkiem jest użycie funkcji WRITELN bez żadnych argumentów (także bez nawiasu), które powoduje zakończenie wiersza i przejście kursora do następnego wiersza.
Wielkości wypisywane przez procedury WRITE i WRITELN można formatować - tzn. określać od której kolumny rozpocznie się ich wypisywanie, a dla wartości liczbowych dodatkowo można określić ilość miejsc przed i po znaku separatora dziesiętnego.
Formatowanie wielkości typu CHAR, logicznego, łańcuchowego i liczb całkowitych odbywa się poprzez wstawienie za wartością znaku ":" i liczby określającej ilość kolumn zajmowanych przez wartość.
Formatowanie wielkości typu rzeczywistego odbywa się podobnie jak dla liczb całkowitych. Znak ":" i pierwsza liczba określają ilość kolumn, które ma zajmować wypisywana wartość. Dodatkowo może wystąpić drugi znak ":" i liczba, która określa ilość cyfr po separatorze dziesiętnym. Liczby są odpowiednio zaokrąglane.
Wartości wyrównywane są prawostronnie. Wartości nie mieszczące się w zadanym polu powodują jego rozszerzenie.
Przy formatowaniu wartości liczbowych należy pamiętać, że do wartości należy także znak i separator dziesiętny!
Przykład:
WRITELN('A=':10,a:0:3);
READ i READLN
Procedury READ i READLN służą do wczytywania danych z klawiatury. Różnica pomiędzy nimi polega na tym, że procedura READLN po wczytaniu zadanych wartości pomija wszystkie inne znaki wprowadzone przez użytkownika aż do naciśnięcia klawisza ENTER (znaku nowej linii). Ma to znaczenie przy wczytywaniu dużej ilości danych (np. macierzy).
Procedura RAEDLN bez parametrów czeka aż użytkownik naciśnie klawisz ENTER - taka konstrukcja jest często stosowana jako element wstrzymujący wykonywanie programu do chwili, kiedy użytkownik pozwoli na kontynuacje (np. aby można było zapoznać się z wynikami).
Jeszcze pare słów o poleceniu Dec i Inc. Istnieje możliwość ustawienia zakresu o który wartość ta ma być zwiększana:
Inc(i, 2);
Takie coś powoduje zwiększanie zmiennej i nie o jeden, ale o dwa oczka....
Low() - zwraca wartość najmniejszą typu lub zmiennej będącej argumentem funkcji
Hight() - zwraca wartość najmniejszą typu lub zmiennej będącej argumentem funkcji
Funkcje "Pred" i "Succ"
Funkcje te mają bardzo podobne działania do Inc i Dec. Z tą różnicą, że Perd i Succ zwraca rezultad gdyż jest to funkcja. Pred zmniejsza o jeden swój parametr:
Pred(10); // zmniejszanie o jeden - da cyfre 9
Natomiast Succ odwrotnie - zwiększa o jeden:
Succ(9); // zwiększenie o jeden - da cyfrę 10
Object Pascal oferuje także zaokrąglanie liczb w górę lub w dół. Służa do tego polecenia: Trunc i Round:
I := Round(8 / 3); // zaokrąglanie do góry - da cyfre 3
I := Trunc(8 / 3); // zaokrąglanie do dołu - da 2
możliwe jest także obcinanie reszty do zera lub miejsca przed przecinkiem do zera.
I := Frac(8 / 3); //0.667
I := Int(18 / 3); // da 2
W tym przykładze następuje rzutowanie zmiennej "Byte" na "Char".
var
B : Byte;
C : Char;
begin
B := 123; // jakas cyfra
C := Char(B); // rzutowanie
ShowMessage(C);
var
B : Byte;
C : Char;
begin
B := 123; // jakas cyfra
C := Chr(B); // zamiana ( uzyskanie znaku poprzez zamiane cyfry )
ShowMessage(C);
Istnieje też funkcja, która to odwraca - tzn., podajesz znak, a funkcja zamienia ten znak na numer ASCII tego znaku. Do tego służy funkcja "Ord":
var
B : Byte;
C : Char;
begin
C := '{'; // znak
B := Ord(C); // uzyskanie numeru znaku
ShowMessage(IntToStr(B)); // wyswietlenie numeru
Słowa kluczowe i dyrektywy języka
1)--------------------------------------------------------------------------------------------------------------------------------------------Słowa kluczowe
W wersji 7.0 języka Turbo Pascal słowem kluczowym nazywamy każdy z 49 następujących wyrazów języka angielskiego:
and |
file |
nil |
shr |
array |
for |
not |
string |
asm |
function |
object |
then |
begin |
goto |
of |
to |
case |
if |
or |
type |
const |
implementation |
packed |
unit |
constructor |
in |
procedure |
until |
destructor |
inherited |
program |
uses |
div |
inline |
record |
var |
do |
interface |
repeat |
while |
downto |
label |
set |
with |
else |
mod |
shl |
xor |
end |
|
|
|
Słowa kluczowe są integralną częścią języka Turbo Pascal, pełnią w nim ściśle określone zadania. Ich Identyfikatory (nazwy) są zastrzeżone, tzn. nie mogą być zdefiniowane przez programistę. Słowa kluczowe można zapisywać za pomocą dużych jak i małych liter. Wiele edytorów przeznaczonych dla języka Pascal wyświetla słowa kluczowe pogrubioną czcionką, co poprawia czytelność programu i eliminuje błędy literowe.
2)------------------------------------------------------------------------------------------------------------------------------------------------Dyrektywy
Oprócz słów kluczowych w wersji 7.0 Pascal-a występują dyrektywy języka. Dyrektywą jest każdy z 10. następujących wyrazów:
absolute |
far |
near |
public |
assembler |
forward |
private |
virtual |
external |
interrupt |
|
|
W odróżnieniu od słów kluczowych, dyrektywy języka nie są zastrzeżone - podane 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.
Instrukcje
Czynności wykonywane na danych są opisywane za pomocą instrukcji. Instrukcje języka Pascal dzielą się na instrukcje proste, tj. takie, które nie zawierają jako składowych innych instrukcji, oraz instrukcje strukturalne, zbudowane na podstawie pewnego schematu strukturalizacji kilku instrukcji.
Oto pełen podział instrukcji:
1) Instrukcje proste
1.1) Instrukcje przypisania
1.2) Instrukcje skoku
1.3) Instrukcje puste
1.4) Instrukcje wywołania procedury
1.5) Instrukcje inline
2) Instrukcje strukturalne
2.1) Instrukcje złożone
2.2) Instrukcje warunkowe
a) Instrukcje if .. then ("jeśli")
b) Instrukcje case .. of (wyboru)
2.3) Instrukcje iteracyjne
a) Instrukcje for .. do ("dla")
b) Instrukcje while .. do ("dopóki")
c) Instrukcje repeat .. until ("powtarzaj")
2.4) Instrukcje wiążące
2.5) Instrukcje asemblerowe
1. INSTRUKCJE PROSTE
1.1)----------------------------------------------------------------------------------------------------------------------------------Instrukcja przypisania
Instrukcja przypisania służy do nadania (inicjalizacja) lub przypisania zmiennej nowej wartości. Składnia instrukcji przypisania jest następująca:
Identyfikator_zmiennej:=wyrażenie;
lub
Identyfikator_funkcji:=wyrażenie;
Wyrażenie to dowolne wyrażenie operujące na danych (lub funkcjach).
Dla każdego przypisania wartość wyrażenia musi być zgodna w sensie przypisania z typem zmiennej.
Przykłady:
a:=1;
tekst:="Kurs Pascala";
x:=x+1
warunek:=a=b;
1.2)-----------------------------------------------------------------------------------------------------------------------------------------Instrukcja skoku
Instrukcja skoku jest jedyną instrukcją, której stosowanie nie jest zalecane. Jej stosowanie zmniejsza przejrzystość programu, utrudnia jego optymalizację, itd. Instrukcja ta może być zawsze zastąpiona instrukcjami "dopóki" lub "powtarzaj". Ogólna jej postać jest następująca:
GOTO etykieta;
Powoduje to przekazanie sterowania do instrukcji programu poprzedzonej podaną etykietą.
Przykład:
PROGRAM Etykiety;
LABEL et;
...
BEGIN
...
GOTO et;
...
x := a+2;
...
END.
1.3)------------------------------------------------------------------------------------------------------------------------------------------Instrukcja pusta
Zapisanie instrukcji pustej nie wymaga użycia żadnego symbolu języka i nie powoduje ona wykonania żadnych czynności. Instrukcję tą stosuje się w tych kontekstach, w których jest wymagane użycie instrukcji, ale chce się uniknąć wykonania jakiejkolwiek czynności, lub w celu ułatwienia opracowania programu.
1.4)---------------------------------------------------------------------------------------------------------------------Instrukcja wywołania procedury
Instrukcja wywołania procedury jak sama nazwa wskazuje służy do wywoływania w programie procedur. Ogólna postać wywołania jest następująca:
Identyfikator_Procedury;
lub
Identyfikator_Procedury(lista_parametrów);
Przykład:
Jeśli w części opisowej programu zadeklarujemy następującą procedurę:
PROCEDURE(X,Y:Byte;Tekst:String[10]);
BEGIN
...
END;
To aby tą procedurę wywołać to w części wykonawczej programu piszemy:
PROCEDURE(10,10,"Kurs Pascala");
1.5)------------------------------------------------------------------------------------------------------------------------------------------Instrukcja inline
Do dołączania w programie lub module krótkich podprogramów lub instrukcji napisanych w kodzie maszynowym służy dyrektywa i instrukcja inline.
Jej postać jest następująca:
INLINE (lista_elementów_inline);
Aby korzystać z tej instrukcji konieczna jest znajomość Asemblera. Wstawki asemblerowe mają za zadanie zwiększyć wydajność kodu.
Przykład:
INLINE ($CD/$12/$89/$46/$04);
2. INSTRUKCJE STRUKTURALNE
2.1)--------------------------------------------------------------------------------------------------------------------------------------Instrukcja złożona
Instrukcja złożona jest ciągiem instrukcji poprzedzonym słowem kluczowym BEGIN i zakończonym słowem kluczowym END. Instrukcje wchodzące w skład instrukcji złożonej wykonywane są sekwencyjnie. Struktura tej instrukcji jest następująca:
BEGIN
Instrukcja_1;
Instrukcja_2;
...
Instrukcja_n
END
Przykład:
BEGIN
a:=1;
b:=a+4;
c:=a-b;
GOTO Przypadek;
END
2.2)----------------------------------------------------------------------------------------------------------------------------------Instrukcja warunkowa
Instrukcje warunkowe uzależniają wykonywanie innych instrukcji od spełnienia określonego warunku. W Pascalu istnieją dwie instrukcje warunkowe: instrukcje IF .. THEN ("jeśli"), instrukcje CASE .. OF (wyboru).
2.2.a)---------------------------------------------------------------------------------------------------------------------------------Instrukcja IF .. THEN
Instrukcja IF .. THEN uzależnia wykonywanie innej lub innych instrukcji od spełnienia lub niespełnienia podanego warunku. Ogólna jej postać jest następująca:
IF wyrażenie THEN
instrukcja;
lub
IF wyrażenie THEN
instrukcja;
ELSE instrukcja
Przy czym wartością wyrażenia powinna być wartość logiczna True lub False. Instrukcja występująca po słowie kluczowym THEN lub ELSE może być dowolną instrukcją prostą lub strukturalną. Jeśli wartością wyspecyfikowanego wyrażenia jest True, to zostanie wykonana instrukcja podana po słowie THEN. W przeciwnym przypadku wykonana będzie następna instrukcja po instrukcji IF (gdy brak ELSE) lub instrukcja podana po słowie ELSE.
Przykład:
IF X=Y THEN A:=0
ELSE A:=1;
Instrukcje warunkowa może zawierać inną instrukcję warunkową, technika taka nazywa się zagnieżdżeniem. Liczba poziomów zagnieżdżeń nie jest ograniczona, ale duża liczba poziomów zmniejsza czytelność programu i może być przyczyną błędów.
2.2.b)---------------------------------------------------------------------------------------------------------------------------------Instrukcja CASE .. OF
W programowaniu często mamy do czynienia z sytuacją, gdy wykonanie różnych operacji jest uzależnione od wartości pewnej zmiennej. Pomocna może się tu okazać instrukcja wyboru, której ogólna postać jest następująca:
CASE wyrażenie OF
instrukcja;
END
lub
CASE wyrażenie OF
instrukcja;
ELSE instrukcja
END
Wartość wyrażenia musi być typu porządkowego.
Instrukcja występująca po słowie kluczowym OF lub ELSE może być dowolną instrukcją prostą lub strukturalną.
Instrukcja poprzedzona jest dwukropkiem oraz jedną lub kilkoma stałymi, zwanymi stałymi wyboru. Można je zdefiniować w postaci jednej liczby (wartości), ciągu wartości oddzielonego przecinkami lub zakresu w postaci Wartość_Poczatkowa ..Wartość_Końcowa. Ponadto dopuszczalne jest stosowanie połączenia w wyliczaniu pojedynczych wartości i zakresów.
Przykłady:
CASE znak OF
'+' : BEGIN
d:=d+1;
z:=z-1;
END;
'-' : BEGIN
d:=d-1;
z:=z+1;
END;
END;
PROGRAM liczydlo;
VAR x:integer;
BEGIN
write('Podaj liczbe: ');
readln(x);{pobiera wartosc x}
CASE x of
0:write('Liczba=0');
1..10: write('Liczba z przedzialu 1-10');
11..100:write('Liczba z przedzialu 11-100') {<- nie ma średnika przed "else"}
ELSE write('Liczba wieksza od 100');
END.
Instrukcja CASE często znajduje zastosowanie razem z typem wyliczeniowym - np. do wypisywania na ekran wartości tego typu.
2.3)------------------------------------------------------------------------------------------------------------------------------------Instrukcje iteracyjne
Instrukcje iteracyjne służą do organizowania cykli programowych, tj. wielokrotnego wykonywania pewnych sekwencji instrukcji. W Pascalu istnieją trzy rodzaje instrukcji iteracyjnych: instrukcje FOR .. DO ("dla"), instrukcje WHILE .. DO ("dopóki") i instrukcje REPEAT .. UNTIL ("powtarzaj").
2.3.a)----------------------------------------------------------------------------------------------------------------------------------Instrukcja FOR .. DO
Pętlę FOR .. DO stosuje się zwykle w celu wykonania pewnej grupy instrukcji w przypadku, gdy liczba powtórzeń jest znana w danym miejscu programu. Sekwencja instrukcji w pętli zostanie wykonana dla wartości zmiennej określonej po słowie FOR zmieniającej się od wartości początkowej (wyrażenie_1) do wartości końcowej (wyrażenie_2) ze skokiem 1.
Instrukcja iteracyjna FOR .. DO może mieć jedną z dwu postaci:
FOR zmienna:=wyrażenie_1 TO wyrażenie_2 DO intrukcja
lub
FOR zmienna:=wyrażenie_1 DOWNTO wyrażenie_2 DO intrukcja
Zmienna, zwana zmienną sterującą, musi być identyfikatorem typu porządkowego, której przypisujemy wartość początkową (wyrażenie_1) w bloku zawierającą daną instrukcję FOR .. DO. Zmiennej tej można używać w instrukcjach pętli lecz nie powinno się jej modyfikować.
Wartość wyrażenia 1 i wyrażenia 2 powinna być zgodna w sensie przypisania z typem zmiennej sterującej.
Obie formy instrukcji FOR .. DO są bardzo podobne, różnica polega na zastosowaniu słów kluczowych TO i DOWNTO. W pierwszym przypadku wartość zmiennej sterującej będzie zwiększana w każdej iteracji pętli, natomiast w drugim przypadku wartość tej zmiennej będzie zmniejszana.
Instrukcja występująca po słowie kluczowym DO może być dowolną instrukcją prostą lub strukturalną.
Przykłady:
FOR i:=1 TO 10 DO x:=x+i;
Instrukcja wykonywana 10-krotnie powoduje zwiększenie zmiennej x o aktualną wartość zmiennej i.
FOR j:=10 DOWNTO 1 DO x:=x+j;
Instrukcja wykonywana 10-krotnie (od tyłu) powoduje zwiększenie zmiennej x o aktualną wartość zmiennej i.
2.3.b)-------------------------------------------------------------------------------------------------------------------------------Instrukcja WHILE .. DO
Pętla WHILE .. DO służy do wielokrotnego wykonywania instrukcji, "dopóki" spełniony jest warunek sprawdzany przed wykonaniem instrukcji. Stosujemy ją wówczas gdy nie umiemy jednoznacznie określić ilość iteracji przed wykonaniem programu.
Instrukcję iteracyjną WHILE .. DO zapisujemy w następującej postaci:
WHILE wyrażenie DO intrukcja
Wyrażenie, które najczęściej jest wyrażeniem porównania, powinno w wyniku dawać wartość logiczną (TRUE lub FALSE), a instrukcja występująca po słowie DO może być dowolną instrukcją prostą lub strukturalną. Instrukcja ta wykonywana jest tak długo jak długo wartością wyrażenia jest TURE.
Przykład:
k:=1;
WHILE k<10 DO BEGIN
x:=x*x;
k:=INC(k) {INC(k) działa jak k:=k+1;};
END;
2.3.c)------------------------------------------------------------------------------------------------------------------------Instrukcja REPEAT .. UNTIL
Pętla REPEAT .. UNTIL służy do wielokrotnego "powtarzania" instrukcji i jest stosowana gdy nie umiemy określić ilości iteracji przed rozpoczęciem programu. W odróżnieniu od instrukcji iteracyjnej WHILE .. DO warunek kontynuowania iteracji jest sprawdzany na końcu pętli. Konsekwencją tych różnic jest to, że gdy warunek nie jest spełniony to instrukcje wewnętrzne pętli REPEAT .. UNTIL wykonają się jeden raz, natomiast instrukcje w pętli WHILE .. DO nie zostaną wykonane.
Instrukcja iteracyjna REPEAT .. UNTIL przybiera następującą postać:
REPEAT
Instrukcja_1
Instrukcja_2
...
Instrukcja_n
UNTIL wyrażenie
Wyrażenie powinno dawać w wyniku wartość logiczną, a każda z instrukcji może być dowolną instrukcją prostą lub strukturalną. Zakończenie przetwarzania instrukcji w pętli następuje, gdy wartością wyrażenia występującego po słowie kluczowym until jest logiczna prawda - True.
Przykład:
i:=1;
REPEAT
Writeln('Linia ',i);
i:=i+1;
UNTIL i=10;
Uwagi dotyczące instrukcji iteracyjnych
W każdym przypadku trzeba uważać by nie powstała pętla nieskończona.
Mogą nam to ułatwić dwie komendy BREAK i CONTINUE. Instrukcja BREAK działa tak, że jeśli zostanie użyta w pętli to ta pętla zostanie zakończona.
Gdy jedną z wewnętrznych instrukcji jest komenda CONTINUE to wszystkie komendy po tej instrukcji zostaną zignorowane i program powróci do początku pętli. Na koniec popatrzmy na program w którym zastosowano trzy rodzaje pętli i każda będzie wykonywać to samo.
PROGRAM petle;
VAR x:integer; {zmienna porzadkowa}
BEGIN
{pętla no.1 "repeat"}
x:=0;
REPEAT
x:=x+1;
writeln(x);
UNTIL x=10;
{pętla no.2 "while"}
x:=0;
WHILE x<>10 DO BEGIN
x:=x+1;
writeln(x);
END;
{pętla no.3 "for"}
FOR x:=0 TO 10 DO writeln(x);
END.
W każdym przypadku zadanie jest to samo, ale za trzecim razem zostają wypisane liczby od 0-10, a nie jak wcześniej 1-10. Dzieje się to dlatego, że pętla zostaje wykonana jeszcze przed zwiększeniem wartości x wiec pierwszą cyfrą będzie zero.
Stosując w programie instrukcje iteracyjne należy zachować szczególną ostrożność ponieważ popełnienie błędy są trudne do wykrycia.
Każdą pętle można "zagnieżdżać" tzn. w jednej stosować drugą, lecz nie jest to wskazane, ponieważ wzrasta komplikacja programu prowadząca do chaosu.
2.4)----------------------------------------------------------------------------------------------------------------------------------------Instrukcja wiążąca
Do odwołania się do poszczególnych pól rekordu lub obiektu służą desygnatory pól, składające się z identyfikatora odpowiedniego pola i nazwy zmiennej rekordowej lub obiektowej. Zastosowanie instrukcji wiążącej pozwala na wygodniejsze odwołanie się do wspomnianych pól, a także zwiększa czytelność programu. Jej postać jest następująca:
WITH lista_zmiennych DO instrukcja
Lista zmiennych zawiera oddzielone przecinkami identyfikatory zmiennych rekordowych lub obiektowych, a instrukcja po słowie kluczowym do może być dowolną instrukcją prostą lub strukturalną. Umieszczenie zmiennej rekordowej lub obiektowej po słowie kluczowym WITH pozwala wewnątrz instrukcji wiążącej na odwołanie się do pól tej zmiennej za pomocą samych identyfikatorów pól. Identyfikatory te traktowane są w instrukcji wewnętrznej jako zmienne.
Przykład:
Załóżmy następującą deklarację:
VAR comp: RECORD
re,im: Real;
END;
Przypisanie do tego rekordu w instrukcji wiążącej jest następujące:
WITH comp DO
BEGIN
re:=1;
im:=1;
END;
Jest to równoważne z takim przypisaniem w instrukcji złożonej:
BEGIN
comp.re:=1;
comp.im:=1;
END;
2.5)--------------------------------------------------------------------------------------------------------------------------------Instrukcja asemblerowa asemblerowa
Instrukcja asemblerowa służy do umieszczania w kodzie źródłowym języka Turbo Pascal instrukcji zapisanych za pomocą asemblera.
Przybiera następującą formę:
ASM
instrukcja_asemblera_1
instrukcja_asemblera_2
...
instrukcja_asemblera_n
END;
Jeżeli kilka instrukcji asemblerowych znajdują się w jednej linii to należy używać separatorów. Gdy poszczególne komendy są umieszczone w kolumnie wówczas separatorem jest znacznik nowej linii.
TYPY DANYCH
Zmienne i stałe reprezentują w programie dane, które charakteryzują programowane zagadnienie z świata rzeczywistego lub wirtualnego.
Przy deklaracji stałej i zmiennej należy podać jej typ, który określa jaki rodzaj danych, z jakiego zakresu, z jaką precyzją będzie przechowywany w stałej lub zmiennej.
Podział typów danych:
1) Typy proste
1.1) Typy porządkowe
a) Typ wyliczeniowy
b) Typy całkowite
c) Typy logiczne
d) Typ znakowy
e) Typy okrojone
1.2) Typy rzeczywiste
2) Typy łańcuchowe
3) Typy strukturalne
3.1) Typy tablicowe
3.2) Typ rekordowy
3.3) Typ zbiorowy
3.4) Typ plikowy
4) Typy wskaźnikowe
5) Typy proceduralne
6) Typ obiektowy
1)--------------------------------------------------------------------------------------------------------------------------------------------------Typy proste
Typy proste są podstawowymi typami języka Pascal i za ich pomocą określa się bardziej złożone struktury danych. Wszystkie typy proste składają się ze skończonego i uporządkowanego zbioru wartości. Dzięki temu na wartościach tych typów możemy m.in. wykonywać operacje porównań. Typy proste dzielimy na typy porządkowe i typy rzeczywiste.
1.1)---------------------------------------------------------------------------------------------------------------------------------------Typy porządkowe
Typami porządkowymi nazywamy wszystkie typy proste z wyjątkiem typów rzeczywistych. Wyróżnienie to jest spowodowane faktem, że typy rzeczywiste często nie mogą występować w kontekście dozwolonym dla innych typów prostych.
Dla wartości każdego typu porządkowego są określone wartości poprzednie i następne (z wyjątkiem wartości krańcowych). Do typów porządkowych zaliczamy: typ wyliczeniowy, typy całkowite, logiczne, typ znakowy i typy okrojone.
1.1.a)-----------------------------------------------------------------------------------------------------------------------------------Typy wyliczeniowe
Typ wyliczeniowy stosuje się zwykle dla zbiorów o niewielkiej liczbie elementów, na których nie wykonuje się operacji arytmetycznych. Definicja jednego typu wyliczeniowego jest następująca:
TYPE identyfikator_typu = (lista_identyfikatorów);
Elementy typu wyliczeniowego są uporządkowane zgodnie z kolejnością ich wyliczenia w definicji typu i posiadają liczby porządkowe odpowiednio 0,1,2 itd.
Przykłady:
TYPE Uczniowie = (Antek, Franek, Zenek);
{Antek ma 0, Franek ma 1, a Zenek 2}
P_roku = (wiosna, lato, jesień, zima);
1.1.b)---------------------------------------------------------------------------------------------------------------------------------------Typy całkowite
Typy całkowite są w języku Pascal predefiniowane i nie wymagają opisu w programie. Wszystkie typy całkowite są podzbiorami zbioru liczb całkowitych. Wśród typów całkowitych wyróżniamy:
Typy całkowite
Typ |
Zakres |
Rozmiar w bajtach |
Integer |
-32768...32767 |
2 |
ShortInt |
-128...127 |
1 |
LongInt |
-2147483648...2147483647 |
4 |
Byte |
0...255 |
1 |
Word |
0...65535 |
2 |
Przykład:
Przypuśćmy, że zdefiniowaliśmy nowy typ:
TYPE Liczba = Integer;
W takim razie poniższa deklaracja
VAR i,j: Liczba;
jest równoważna deklaracji
VAR i,j: Integer;
1.1.c)------------------------------------------------------------------------------------------------------------------------------------------Typy logiczne
Standardowymi typami logicznymi są typy Boolean, ByteBool, WordBool i LongBool.
Wartości typów logicznych są oznaczone za pomocą dwu predefiniowanych literałów (stałych): True i False, oznaczających odpowiednio wartości logiczne fałsz i prawda, przy czym w sensie uporządkowania stała False poprzedza stałą True.
Liczbami porządkowymi elementów typu Boolean są tylko 0 (False) i 1 (True).
Elementy pozostałych typów logicznych mogą posiadać inne (wyższe) liczby porządkowe.
1.1.d)------------------------------------------------------------------------------------------------------------------------------------------Typ znakowy
Do oznaczenia typu znakowego służy predefiniowany identyfikator Char.
Elementami typu znakowego są znaki ASCII, z których każdy jest pamiętany w jednym bajcie pamięci.
Przykład:
Deklaracja zmiennej znakowej:
Var literka: Char;
Zmiennej literka możemy przypisać literę 'A' na trzy różne sposoby:
literka:='A';
lub za pomocą kodu ASCII
literka:=chr(65);
literka:=#65;
1.1.e)-----------------------------------------------------------------------------------------------------------------------------------------Typy okrojone
Typy okrojone służą do ograniczania zakresów wartości dowolnego z dotychczas opisanych typów porządkowych. Definicja jednego typu okrojonego ma postać
TYPE identyfikator_typu = stała .. stała;
Pierwsza stała podaje ograniczenie dolne i nie może być większa od drugiej - ograniczenia górnego. Stałe te muszą być tego samego typu porządkowego.
Typ okrojony ma pewne ograniczenia w porównaniu z typami porządkowymi. Nie można na nim stosować działań, ani pobierać wartości z klawiatury lub wyświetlić ich na ekran.
Przykład:
TYPE Litery = 'A' .. 'Z';
1.2----------------------------------------------------------------------------------------------------------------------------------------Typy rzeczywiste
Do typów prostych należą także standardowe typy rzeczywiste, które jednak nie są typami porządkowymi. Typ porządkowy różni się od typu rzeczywistego tym, że do typu rzeczywistego należą liczby rzeczywiste i w konsekwencji tego, komputer nie może odnaleźć wartości mniejszej lub większej tego typu. Ma to znaczenie w instrukcji "for" i tablicach. Każdy z dostępnych typów rzeczywistych jest dyskretnym i skończonym podzbiorem zbioru liczb rzeczywistych. Dostępnych jest pięć standardowych typów rzeczywistych o następujących predefiniowanych identyfikatorach:
Typy rzeczywiste
Typ |
Zakres |
Liczba cyfr znaczących |
Rozmiar w bajtach |
Real |
2.9e-39...1.7e+38 |
11-12 |
6 |
Single |
1.5e-45...3.4e+38 |
7-8 |
4 |
Double |
5.0e-324...1.7e+308 |
15-16 |
8 |
Extended |
1.9e-4951...1.1e+4932 |
19-20 |
10 |
Comp |
-263+1 ... 263-1 |
19-20 |
8 |
2)------------------------------------------------------------------------------------------------------------------------------------------Typy łańcuchowe
Typy łańcuchowe (tekstowe) służą do reprezentowania ciągu znaków, w tym niewidocznego znaku spacji. Elementami typu łańcuchowego są łańcuchy o długości od 0 do długości podanej w definicji typu łańcuchowego.
Typ ten definiuje się następująco:
TYPE identyfikator_typu = String[rozmiar];
lub
TYPE identyfikator_typu = String;
gdzie rozmiar jest liczbą typu Byte. Brak wyspecyfikowania rozmiaru powoduje domyślne przyjęcie długości 255 znaków (wartość maksymalna).
Przykład:
TYPE Nazwisko = String[20];
tekst:='Kowalski'
3)-------------------------------------------------------------------------------------------------------------------------------------------Typy strukturalne
Typy strukturalne stosuje się do opisu obiektów złożonych, przy czym dany obiekt możemy opisać na kilka różnych sposobów. Każdy z typów strukturalnych definiowany jest przez podanie typów składowych i metody strukturalizacji, która zarazem określa sposób dostępu do elementów składowych. W ogólności definicja pojedynczego typu strukturalnego ma postać:
TYPE Identyikator_typu = Opis_typu_strukturalnego;
przy czym opis typu strukturalnego może być opisem typu tablicowego, rekordowego, zbiorowego lub plikowego.
3.1)--------------------------------------------------------------------------------------------------------------------------------------------Typ tablicowy
Typ tablicowy, a konkretnie tablica składa się z ustalonej liczby elementów tego samego typu, zwanego typem składowym, który może być zarówno typem prostym lub łańcuchowym, jak i typem strukturalnym. Za pomocą tablic są reprezentowane regularne układy danych, np. wektory i macierze. Dostęp do poszczególnych elementów tablic uzyskuje się za pomocą indeksowania. Indeksem może być dowolne wyrażenie, którego wartość jest zgodna w sensie przypisania z typem indeksowym. Dopuszczalny zakres indeksów jest podany w definicji typu tablicowego. Definicja pojedynczego typu tablicowego ma postać:
TYPE Identyfikator_typu = array[typy_indeksowe] of typ_składowy;
gdzie typy indeksowe są opisami typu porządkowego (z wyjątkiem typu LongInt), przy czym poszczególne opisy oddziela się przecinkami. Typ składowy oznacza dowolny typ.
Przykłady:
TYPE Macierz = array[1..20,1..30] of Real;
Tablica = array[Boolean,1..20,znak] of Char;
Istnieje sposób, aby tablice wypełnić jako stałą w sekcji const:
CONST
Tablica : array[0..2] of Char = ('Adam', 'Marta', 'Magda');
3.2)-------------------------------------------------------------------------------------------------------------------------------------------Typ rekordowy
Typem rekordowym, a dokładniej rekordem nazywamy złożoną strukturę danych, której składowe, zwane polami, mogą mieć różne charakterystyki (należeć do różnych typów). Poszczególne pola mogą być same strukturami złożonymi, przy czym liczba pól rekordu jest ustalona. Definicja typu rekordowego określa typ i identyfikator dla każdego pola. Definicja ta rozpoczyna się słowem kluczowym record, po którym podaje się deklarację każdego pola, a kończy słowem kluczowym end. Poszczególne deklaracje pól oddziela się średnikami. Ostatnia deklaracja może być wariantowa (case .. of). Definicja pojedynczego typu rekordowego ma postać:
TYPE Identyfikator_typu = record
Lista_deklaracji_pól
end;
gdzie każda z deklaracji pól ma postać:
lista_nazw_pól : opis_typu;
a ostatnia deklaracja może mieć postać (deklaracja wariantowa):
case deklaracja_pola_wyróżnikowego of wykaz_wariantów;
lub
case identyfikator_typu_porządkowego of wykaz_wariantów;
przy czym deklaracja pola wyróżnikowego wygląda następująco:
identyfikator_pola_wyróżnikowego :
identyfikator_typu_porządkowego;
lub
lista_etykiet_wyboru : (lista_deklaracji_pól);
Przykłady rekordów:
TYPE Data = record
rok : Integer;
miesiac : 1 .. 12;
dzien : 1 .. 31;
end;
TYPE Rejestry = record
case Integer of
1: (AX, BX, CX, DX : Word);
2: (AL, AH, BL, BH, CL, CH,
DL, DH : Byte);
end;
end;
3.3)---------------------------------------------------------------------------------------------------------------------------------------------Typ zbiorowy
Typ zbiorowy jest zbiorem potęgowym danego typu porządkowego, tzn. jest zbiorem wszystkich podzbiorów tego typu, w tym zbioru pustego. Liczba elementów typu zbiorowego nie może przekraczać 256 (przedział od 0 do 255). Definicja pojedynczego typu zbiorowego ma postać:
TYPE Identyfikator_typu = set of typy_porządkowy;
Przykład:
TYPE Klasy = set of (LO_1d, LO_2d, LO_3d,LO_4d);
elementami typu Klasy może być dowolny podzbiór zbioru podanych nazw klas, m.in :
[ LO_1d, LO_2d ] - podzbiór dwuelementowy
[ LO_3d ] - podzbiór jednoelementowy
[ ] - zbiór pusty
[ LO_1d, LO_2d, LO_3d, LO_4d ] - podzbiór czteroelementowy
3.4)---------------------------------------------------------------------------------------------------------------------------------------------Typy plikowe
Typy plikowe są ściśle powiązane z plikami. Plik jest ciągiem elementów tego samego typu, tyle że liczba jego składowych jest zmienna. Jest ona uzależniona od przebiegu wykonywania programu, a w szczególności od skojarzenia pliku z fizycznym zbiorem danych. Od tablicy plik różni się ponadto metodą dostępu do poszczególnych elementów. Definicja pojedynczego typu plikowego ma postać:
TYPE Identyfikator_typu = file of opis_typu_elementów_pliku;
lub
TYPE Identyfikator_typu = file;
Jeżeli w definicji typu plikowego pominięto słowo kluczowe of i opis typu jego elementów, to przyjmuje się, że dany typ plikowy jest niezdefiniowany. Niezdefiniowane pliki są stosowane głównie w celu dostępu do fizycznych zbiorów dyskowych zgodnie z ich wewnętrznym formatem. W Pascalu istnieje predefiniowany plik tekstowy o nazwie Text (standardowy typ plikowy).
Przykłady:
TYPE Dane = file of Integer;
Zbior = file;
Wyniki = Text;
4)--------------------------------------------------------------------------------------------------------------------------------------Typy wskaźnikowe
Typy wskaźnikowe. Zmienne dotychczas omówionych typów, tj. typów prostych i strukturalnych, charakteryzują się tym, że istnieją przez cały czas wykonywania tej części, w której są zadeklarowane. Są to tzw. zmienne statyczne.
W języku Pascal występują też zmienne dynamiczne reprezentujące obiekty, dla których pamięć jest przydzielana i zwalniana na określone żądanie. Zmienne te nie posiadają identyfikatorów, a odwołanie do nich następuje za pomocą wskaźnika. Wartościami wskaźników są elementy typu wskaźnikowego, które określają adresy pamięci zmiennych dynamicznych. Zastosowanie w programie zmiennych dynamicznych pociąga za sobą konieczność zdefiniowania odpowiednich typów wskaźnikowych. Definicja pojedynczego typu wskaźnikowego ma postać:
TYPE Identyfikator_typu = ^Identyfikator_typu_bazowego;
Poprzyjmy to przykładem:
TYPE wskaznik = ^zapis;
zapis = record
Tekst: String[80];
Liczba: Integer;
end;
Definicja ta wiąże typ wskaźnik ze zbiorem wskazań danych typu zapis. Jeśli wprowadzimy teraz deklarację:
VAR adres : wskaznik;
to zmiennej wskaźnikowej adres będą mogły być w programie przypisywane adresy pamięci danych typu zapis.
W Pascalu występują dwa predefiniowane typy wskaźnikowe są to typy Pointer (zmienne tego typu są zgodne z dowolnym innym typem wskaźnikowym) i PChar (reprezentuje wskaźnik do łańcuchów zakończonych znakiem pustym).
Jednym ze słów kluczowych jest słowo nil, które oznacza stałą typu wskaźnikowego nie określającą żadnego adresu (nil wskazuje na adres pusty)
5)-------------------------------------------------------------------------------------------------------------------------------------------Typ proceduralny
Procedury i funkcje mogą być traktowane nie tylko jako części programu wykonywane na skutek wywołania, ale także jako elementy, które mogą być przypisywane do zmiennych i przekazywane do innych funkcji lub procedur jako parametry. Zmienne tego rodzaju powinny być typu proceduralnego Definicja pojedynczego typu proceduralnego może mieć jedną z następujących postaci:
TYPE Nazwa = procedure;
lub
TYPE Nazwa = procedure(lista_parametrów);
lub
TYPE Nazwa = function: typ_wartości_funkcji;
lub
TYPE Nazwa = function(lista_parametrów):
typ_wartości_funkcji;
Przykłady:
TYPE Procedura = procedure;
Proc = procedure(x,y: Byte);
Funkcja = function(x,y: Byte): Boolean;
6)----------------------------------------------------------------------------------------------------------------------------------------------Typ obiektowy
Typ obiektowy. Obiektem w Pascalu nazywa się złożoną strukturę danych o ustalonej liczbie elementów składowych, z których każdy może być polem lub metodą (m.in. procedurą lub funkcją), tj. elementem opisującym operację wykonywaną na danym obiekcie. W definicji typu obiektowego, podobnie jak w definicji typu rekordowego, dla każdego pola specyfikuje się jego typ i identyfikator. Opis metody składa się z nagłówka procedury, funkcji, konstruktora lub destruktora, przy czym definicja pojedynczego typu obiektowego może zawierać opisy wielu metod. Opis typu obiektowego rozpoczyna się od słowa kluczowego object, a kończy słowem kluczowym end. Definicja pojedynczego typu obiektowego ma postać:
TYPE Identyfikator_typu = object dziedzictwo
Lista_deklaracji_pól
Lista_deklaracji_metod
end;
lub
TYPE Identyfikator_typu = object dziedzictwo
Lista_deklaracji_pól
Lista_deklaracji_metod
Sekcje_list
end;
przy czym elementy wyszczególnione pomiędzy słowami object i end są opcjonalne, a każda z sekcji list może mieć jedną z poniższych postaci:
private
Lista_deklaracji_pól
Lista_deklaracji_metod
lub
public
Lista_deklaracji_pól
Lista_deklaracji_metod
przy czym w sekcjach tych oba elementy są także opcjonalne.
Dziedzictwo oznacza ujęty w nawiasy okrągłe identyfikator innego, zdefiniowanego wcześniej, typu obiektowego. Jeśli w definicji typu obiektowego wystąpi ten element, oznacza to, że dany typ obiektowy zawiera (dziedziczy) wszystkie elementy podane w definicji typu obiektowego o wyspecyfikowanej nazwie.
Każda z deklaracji pól ma postać:
Lista_nazw_pól : opis_typu;
a każda deklaracja metody jest następująca:
nagłowek_metody;
lub
nagłowek_metody; virtual;
gdzie nagłówek metody oznacza nagłówek funkcji, procedury, konstruktora lub destruktora. Słowo kluczowe virtual określa daną metodę jako wirtualną.
Definicję poszczególnych metod podaje się poza definicją typu obiektowego. Każda definicja metody zawiera w nagłówku nazwę funkcji, procedury, konstruktora lub destruktora, poprzedzoną kropką i nazwą odnośnego typu obiektowego.
Jeśli definicja typu obiektowego zawiera dyrektywę private, oznacza to, że zakres ważności pól i (lub) metod podanych po tej dyrektywie jest ograniczony do modułu (lub programu), który zawiera definicję danego typu obiektowego. Tego typu pola i metody nazywamy polami i metodami prywatnymi. Użycie po sekcji z dyrektywą private dyrektywy public powoduje anulowanie ograniczenia zakresu ważności dla dalszych pól i (lub) metod.
Przykłady:
TYPE punkt = object
X, Y:Integer;
end;
TYPE piksel = object (punkt)
Kolor:Byte;
end;
Typ obiektowy piksel zawiera elementy typu obiektowego punkt.
TYPE odcinek = object
X, Y:Byte;
procedure zaznacz(dx, dy: Byte);
end;
Dla powyższego typu konieczne jest podanie w dalszej części programu definicji procedury zaznacz:
procedure odcinek.zaznacz(dx, dy: Byte);
begin
... Jakieś_instrukcje
end;
18
19