Pascal

Wersja standardowa

Pierwszy program (1)

Project1

program

PRZYKŁAD_WSTĘPNY

(input,

output);

{ część definicyjna programu

- definicje i deklaracje}

const {definicja stałej}
pi = 3.1415926536;
var {deklaracje zmiennych}

dodatnie, ujemne: integer;
liczba, wynik:

real;

{ część operacyjna programu

- instrukcje }

begin

{inicjacja liczników liczb

dodatnich i ujemnych}
dodatnie:=0; ujemne:=0;
{drukowanie nagłówka

wyników}
writeln('WYNIKI

PRZYKŁADOWEGO

PROGRAMU');
writeln

('------------------------------------

-------------------------');

Pierwszy program (2)

{powtarzanie

zasadniczych akcji aż do

napotkania zera w

danych}
repeat
{wczytanie kolejnej

liczby}
read(liczba);
{badanie znaku liczby,

uaktualnianie liczników,

drukowanie

wyników}

if liczba > 0 then
begin
dodatnie := dodatnie + 1;
wynik := pi * sqr(liczba);
writeln('Dla promienia = ',

liczba:4:2, 'pole koła wynosi:

', wynik:4:2)
end {wariantu dla liczby

dodatniej}
else

Pierwszy program (3)

if liczba < 0 then
begin
ujemne := ujemne + 1;
wynik := 1/liczba;
writeln('Odwrotność liczby ',
liczba:7:4, 'równa się ',
wynik:9:6);
end {wariantu dla liczby
ujemnej}
else

{pozostł już tylko wariant z
liczbą = 0}
writeln('*** koniec danych
wejściowych ***')
until liczba = 0;
{drukowanie końcowej
informacji}
writeln('W ciągu było ', dodatnie
+ ujemne:2, ' liczb, w tym ',
'dodatnie ', dodatnie:2, ',
ujemne', ujemne:2, '.')

end.

Identyfikatory

•

Służą do oznaczania programów, stałych, typów,

zmiennych, pól w rekordach, procedur i funkcji oraz

parametrów formalnych. Powiązanie identyfikatora z

oznaczanym przez niego obiektem jest jednoznaczne w

obszarze stanowiącym zakres działania identyfikatora.

•

Identyfikatory mogą być dowolnej długości.

•

Pewne identyfikatory służą do oznaczania obiektów

standardowych (np. funkcji trygonometrycznych).

Programista ma jednak prawo przedefiniować znaczenie

takich identyfikatorów i lokalnie używać ich do innych

celów.

•

Wyrazy tworzące słowa kluczowe nie mogą być

używane jako identyfikatory.

Liczby

•

Liczby zapisuje się w sposób zbliżony do

konwencjonalnej

notacji

matematycznej,

z

następującymi różnicami:

–

część całkowitą oddzielamy od części ułamkowej kropką,

a nie przecinkiem;

–

dla liczb o małej liczbie cyfr znaczących i jednocześnie

bardzo dużym (lub bardzo małym) module, wprowadzono

skrócony zapis korzystając z tzw. mnożnika skalującego.

 

•

0.345

0.345E-5

•

345e6

3.45E+8

•

345

Etykiety i Napisy

Etykiety
 
etykieta = ciąg_cyfr
 
Etykiety służą do wyróżnienia w programie wybranych

instrukcji.

Etykieta

jest

ciągiem

co

najwyżej

czterocyfrowym.

Napisy
 
'4'

'PASCAL'

'345'

'X''Y' 'Ala ma kota'

Separatory

{ komentarze } spacje tabulacje

znaki_nowej_linii

 

•

Między dwa symbole Pascalowe można wstawić

dowolną liczbę separatorów.

•

Dowolne dwa symbole będące identyfikatorami,

liczbami i słowami kluczowymi muszą być

rozdzielone co najmniej jednym separatorem.

•

Wewnątrz symboli Pascalowych (tzn. pomiędzy

elementami alfabetu, z których są one zbudowane)

nie wolno umieszczać separatorów. Wyjątkiem jest

znak spacji wewnątrz napisu.

Definicje stałych

•

Definicja stałej wprowadza

identyfikator

będący

synonimem stałej.

•

Używanie synonimów stałych

zwiększa

czytelność

programu. Jednocześnie czyni

rozwiązanie bardziej ogólnym

poprzez jego parametryzację

(ułatwia

modyfikację

programu

i

jego

przystosowanie do potrzeb

konkretnego użytkownika).

•

W programie, w którym nie

definiujemy stałych, część

definiująca

stałe

jest

pomijana.

const pi = 3.1415;

koniec_świata

=

3003;

max_data

=

'620323';

znak = '*';
minus_pi = -pi;
pilna_wiadomość =

'Ala nie ma chomika ani
szczura';

Definicje typów

•

Każdą zmienną należy w programie

zadeklarować , tzn. określić jej

nazwę oraz wartości, które może

przyjmować. Zbiór tych wartości

nazywamy typem zmiennej.

•

Typy dzielą się na standardowe i

niestandardowe, w zależności od

tego,

czy

odpowiednie

zbiory

wartości są określone standardowo

w języku, czy też są wprowadzone

w konkretnym programie tylko na

jego doraźny użytek.

•

Dla typów standardowych język

wzorcowy ustala ich nazwy, sposób

oznaczania

poszczególnych

wartości

oraz

dopuszczalne

operacje.

•

Wprowadzając

nowy

typ

niestandardowy, programista
sam

określa

odpowiedni

zbiorów wartości w postaci
opisu typu. Opis taki może
być używany explicite (np. w
deklaracjach zmiennych) bez
uprzedniego nadania temu
typowi nazwy, albo też może
być wprowadzony w definicji
typu.

type A = integer;

B = array [1..10] of real;
C = A;

Typy proste: typy

porządkowe

•

Podklasa nie zawierająca typu rzeczywistego.

•

Na dowolnym typie porządkowym jest

określona funkcja ord przekształcająca ten typ

w typ całkowity integer. Wartością funkcji ord

dla danego elementu typu jest liczba

porządkowa elementu w tym typie.

•

Na każdym typie porządkowym są określone

również funkcje poprzednika pred i następnika

succ wyznaczające odpowiednio element

poprzedni lub następny do danego.

•

Project2

Standardowe typy proste

•

Typ logiczny Boolean o wartościach false i true.

ord(false)=0; ord(true)=1.

•

Typ całkowity integer (podzbiór liczb całkowitych określony stałą

standardową maxint <-maxint, ... , maxint> ).

•

Typ rzeczywisty real (dyskretny i skończony podzbiór zbioru liczb

rzeczywistych). Funkcja ord nie jest określona dla typu real.

Wartości typów integer i real są oznaczane w sposób

konwencjonalny.

•

Typ znakowy char (zbiór znaków zewnętrznych używanych do

komunikacji człowiek-komputer). Wartości typu char oznacza się

przez

ujęcie

znaku

w

pojedyncze

apostrofy.

Istnieje funkcja standardowa chr pozwalająca przekształcić

podzbiór liczb całkowitych na zbiór znaków.

 

•

chr(ord(c)) = c

ord(chr(i)) = i

Typy proste: typy

wyliczeniowe

•

Stosowane w przypadku zbiorów o

niewielkiej liczbie elementów, na których

nie wykonuje się operacji arytmetycznych.

•

Porządek w typie jest zgodny z kolejnością

wyliczenia w jego definicji. Wartości typu

wyliczniowego wymienione kolejno w

definicji typu mają liczby porządkowe

równe odpowiednio 0, 1, 2 ... itd.

•

Dwa różne typy wyliczeniowe nie mogą

mieć wspólnych wartości.

Typy wyliczeniowe (c.d.)

type dzień_tygodnia = (pon, wt, śr, czw, pt, sob, niedz);

rejestr = (CS, DS, SS, ES, AX, BX, CX, DX, SI, DI, SP, BP);
płeć = (kob, męż);
rodzaj_przestępstwa = (kradzież, pobicie, gwałt,

morderstwo);

 

succ(pon) = wt

pred(męż) = kob

pred(kradzież) = nieokreślony

ord(SS) = ord(gwałt)

Project3

Typy proste: typy okrojone

•

Typ

okrojony

umożliwia

ograniczenie zbioru wartości

typu wyliczeniowego.

•

Obie stałe muszą być tego

samego typu porządkowego,

zwanego typem pierwotnym.

Pierwsza ze stałych, zwana

ograniczeniem dolnym, nie

może być większa niż druga

stała (ograniczenie górne).

•

Zmienna typu okrojonego ma

wszystkie

własności

typu

pierwotnego

z

jednym

wyjątkiem - jej wartości należą

do przedziału podanego w

definicji typu okrojonego.

type duża_litera

=

'A'..'Z';
dzień_roboczy

=

pon..pt;
zakres = 1..2000;
rejestr_segmentowy
= CS..ES;
zbrodnia

=

gwałt..morderstwo

Typy strukturalne

•

Są używane do opisu obiektów złożonych.

Definiuje się je za pomocą istniejących w

Pascalu schematów strukturalizacji. Ten sam

obiekt

(abstrakcyjny)

często

może

być

reprezentowany (opisany) w języku na kilka

sposobów.

•

Typ strukturalny jest definiowany przez podanie

typów składowych i metody strukturalizacji,

określającej jednocześnie mechanizm dostępu

do składowych wartości strukturalnej. Dostęp

ten jest realizowany za pomocą selektora.

?

?

Typy strukturalne: tablice

•

Tablica składa się z

ustalonej

liczby

elementów

tego

samego typu zwanego

typem

składowym.

Oznaczenie

typu

postaci:

•

array [T1,T2,...,Tn] of

T jest skrótem

oznaczenia:

•

array [T1] of array [T2,

T3,...,Tn] of T

•

Project5

Powyższa tablica:

•

zwana jest tablicą n-wymiarową;

•

ma

car(T1)*car(T2)*...*car(Tn)

elementów typu T;

•

wartości i1, i2, ..., in należące

odpowiednio

do

typów

indeksowych T1,T2,...,Tn będące

selektorami, są zwane indeksami i

wyznaczają jeden element tablicy;

•

wartości indeksów są obliczane w

chwili odwołania do tablicy;

•

czas dostępu do elementu tablicy

jest dla każdego elementu taki

sam, a więc tablica jest strukturą o

dostępie bezpośrednim.

Tablice (c.d.)

type księgozbiór = array [1..max_książek] of książka;

książka = array [1..max_rozdz] of rozdział;
rozdział = array [1..max_stron] of strona;
strona = array [1..max_wierszy] of wiersz;
wiersz = array [1..80] of char;

type M = array [1..n, 1..m] of real;

zestaw = array [dzień_roboczy] of integer;

array [Boolean] of array [1..10] of array [litera] of

char;

array [Boolean, 1..10, litera] of char;

= array of

= array of

Rozdzia³ 3

fhfdgfd hdsdhfgfd

fdsdffdssdf fdsf fd

ttrtr jhh uuy urr

trrtjk iuku

Rozdzia³ 4

fhfdgfd hdsdhfgfd

fdsdffdssdf fdsf fd

ttrtr jhh uuy urr

trrtjk iuku

Rozdzia³ 4

fhfdgfd hdsdhfgfd

fdsdffdssdf fdsf fd

trrtjk iuku

= array of

. . .

Typy strukturalne:

rekordy

•

Rekord składa się z ustalonej liczby
składowych zwanych polami, które
mogą być różnych typów. Definicja
typu rekordowego specyfikuje dla
każdego

pola

jego

typ

i

identyfikator.

Selektorem

wybieranego pola w rekordzie jest
identyfikator pola.

T

T1

T2

T3

T4

T5

?

array

Rekordy (c.d.)

type zespolone = record re, im : real end;

data = record

dzień: 1..31;

miesiąc: 1..12;
rok: 0..koniec_świata
end;
płeć = (kob, męż);
alfa15 = array [1..15] of char;
osoba = record imię, nazwisko: alfa15;
urodz: data;
case pł: płeć of
kob: (nazw_panieńskie: alfa15);
męż: (brodaty, wąsaty: Boolean;
case ukończył_sł_wojsk: Boolean of
false: ();
true: (data_ukończ: data))
end;

Project6

?

Różne zmienne tego samego typu rekordowego

mogą mieć różniące się struktury.

Sytuacja ta pojawia się wtedy, gdy w opisie wystąpiła

tzw. część zmienna, grupująca kilka możliwych wariantów.

Warianty mogą różnić się liczbą składowych i ich typami.

Typy strukturalne: zbiory

•

Typ zbiorowy jest zbiorem

potęgowym

typu

podstawowego,

tzn.

jest

zbiorem

wszystkich

podzbiorów. Wartości typu

zbiorowego

zapisuje

się

przez

podanie

listy

elementów danego zbioru

ujętej

w

nawiasy

kwadratowe.

•

Na

wszystkich

typach

zbiorowych

są

określone

operatory:

•

+ -

*

in

type dni_świąteczne = set of

pt..niedz;

[], [pt], [sob], [niedz], [pt,sob],

[pt, niedz], [sob,niedz]

[pt,sob,niedz]
type cecha = (zgrabna,

ładna, inteligentna, bogata,

sympatyczna);
kobieta = record
ona: osoba;
opis: set of cecha
end;

Project7

?

Typy strukturalne: pliki

•

Plik jest strukturą składającą się z ciągu

elementów tego samego typu. Liczba

elementów, zwana długością pliku, jest

zmienna w trakcie wykonywania programu.

W dowolnej chwili może być dostępny co

najwyżej jeden element pliku. Pozostałe

mogą

być

dostępne

po

wykonaniu

odpowiedniej

operacji

na

pliku.

Do

dostępnego elementu pliku odwołujemy się

za pomocą zmiennej buforowej.

•

Plik nie może zawierać innych plików.

....

Pliki (c.d.)

type wynik file of char;
moje_znajome file of kobieta;
zesp file of record re, im: real end;

var f: file of integer;

3

-17

0

-3

5

2

eof(f)=false; f^=-3; get(f);

3

-17

0

-3

5

2

eof(f)=false; f^=5; rewrite(f); f^:=8; put(f);

8

eof(f)=true; f^=nieokreślone; f^:=10; put(f);
reset(f);

8

10

eof(f)=false; f^=8;

Typy wskaźnikowe

•

Typ wskaźnikowy jest zbiorem wartości zwanych

wskaźnikami,

wskazujących

na

zmienne

typu

wskazywanego

(identyfikujących

zmienne

typu

wskazywanego). Każdy typ wskaźnikowy zawiera

ponadto tzw. wskaźnik pusty, oznaczany za pomocą

stałej standardowej nil.

 

•

Zbiór wartości typu wskaźnikowego zmienia się

dynamicznie - wskaźniki mogą być tworzone i niszczone

w trakcie wykonywania programu. Początkowo typ

wskaźnikowy zawiera tylko wskaźnik pusty. Inne

elementy tego typu, a także zmienne przez nie

wskazywane

mogą

być

utworzone

za

pomocą

standardowej procedury new.

Typy wskaźnikowe umożliwiają

modelowanie dynamicznych

struktur danych: list, drzew,

stosów, kolejek, itp.

Typy wskaźnikowe (c.d.)

type W = ^T;
var p: W;

p

new(p)

p

zmienna

typu

T

Typy wskaźnikowe (c.d.)

type węzeł_drzewa = record

wartość: kobieta;
l_poddrzewo, p_poddrzewo: ^węzeł_drzewa

end

;

Project8

Zgodność typów

•

Mówimy, że dwa typy są zgodne
jeżeli:

–

jeden z nich jest okrojonym typem
drugiego albo oba są okrojonymi typami
tego samego typu pierwotnego, lub

–

oba są typami zbiorowymi o zgodnych
typach podstawowych, lub

–

oba sa typami napisowymi o tej samej
liczbie składowych.

Poprawność użycia w danej

konstrukcji pascalowej obiektu

takiego jak identyfikator, stała,

zmienna lub funkcja zależy

na ogół od typu tego obiektu.

Zmienne

•

Ze zmienną jest związany sposób jej identyfikacji oraz typ.

•

Każda zmienna musi być zadeklarowana. Deklaracja poprzedza

w tekście programu pierwsze odwołanie do zmiennej.

 
var

i, j, k: integer;

alarm, b: Boolean;
zn: char;
kartoteka: file of osoba;
zbiór: dni_świąteczne;
licznik: array [litera] of integer;
dzisiaj: data;
wskaźnik: ^osoba;
żona: kobieta;

Zmienne (c.d.)

Zmienne całościowe
 
alarm dzisiaj

licznik

zbiór

 
 
Zmienne składowe
 
licznik['A'] dzisiaj.dzień

żona.opis

żona.ona.imię

żona.ona.nazw_panieńskie[1]
licznik[chr(32)]

Zmienne (c.d.)

Zmienne wskazywane
p: ^węzeł_drzewa;
p wskaźnik
p^

rekord typu węzeł_drzewa

p^.wartość

rekord typu kobieta

p^.l_poddrzewo

wskaźnik

p^.l_poddrzewo^

rekord typu węzeł_drzewa

p^.l_poddrzewo^.l_poddrzewo

wskaźnik (nil)

 
Zmienne buforowe
 var

f: zesp;

 f^

f^.re f^.im

Wyrażenia

Operatory multiplikatywne
 

* /

div

mod and

 
Operatory addytywne
 

+ -

or

 
Operatory relacyjne
 

= <> <

>

<=

>=

in

Wyrażenia (c.d.)

Wyrażenia

są

zbudowane

ze

stałych,

zmiennych,

operatorów, nazewników funkcji, zbiorów i nawiasów

okrągłych. Wartościowanie wyrażenia jest uzależnione od

priorytetu

operatorów.

Operatory

o

najwyższym

priorytecie są realizowane najpierw. Ciągi operatorów o

tym samym priorytecie są realizowane od lewej do prawej

strony. Najwyższy priorytet ma operator not, następnie

kolejno operatory multiplikatywne, addytywne i relacyjne.

 
i mod 7

(x <= y) and (y < z)

sin(x+y)

(pon in [czw, pt, sob]) or (tab[5<7].pole1 mod x >= 123)
moja_funkcja(wylicz(sin(x), cos(y), pi), jego_funkcja(x+y),

param3)

Instrukcje

put(wynik);
x := (a+b)/2;
13: if alarm then write(napis);
while j<= n do begin p := p*10;

n:= n*1 end;

goto 13;

Instrukcje proste

Instrukcja przypisania
j := j - 23
alarm := eof(dane)
dzisiaj.miesiąc := 7
kartoteka^.urodz := dzisiaj

Instrukcja procedury
reset(dane)
new(p)
utwórz_nową_kartotekę
wydrukuj(raport, nagłówek,

font, liczba_kopii)

Instrukcja skoku
goto 657
 
Instrukcja pusta
for i := 1 to 10 do

{instrukcja pusta) ;

procedure p;
begin {instrukcja pusta}

end;

Instrukcje strukturalne

•

Instrukcja strukturalna łączy jedną lub

więcej instrukcji (zwanych instrukcjami

wewnętrznymi)

według

pewnego

schematu strukruralizacji. Schemat ten

określa czy instrukcje mają być

wykonywane kolejno, czy mają być

wykonywane tylko niektóre z nich (lub

żadna z nich) zależnie od wartości

określonego warunku, czy też mają być

wykonywane wielokrotnie.

Instrukcja złożona

begin

read(s);
write('Wczytałem: ', s:8:2);
A[i,j] := s

end;

i:=1

j:=j+1

oblicz(i)

write(i)

Instrukcja warunkowa

instrukcja_wrunkowa=if

wyrażenie_logiczne then instrukcja|

if

wyrażenie_logiczne

then

instrukcja
else instrukcja

if eof(dane) then

begin
alarm := true;
goto 13
end;

if płeć = kob then

write('Kobieta')

else write('Chyba mężczyzna');

if płeć = kob then write('Kobieta')
else

if płeć = męż then
write('Mężczyzna);
else write('Ni to, ni owo');

if płeć = kob then write('Kobieta')
else

begin
if płeć = męż then
write('Mężczyzna);
else write('Ni to, ni owo')
end;

?

i < 5

T

N

Instrukcja wyboru

instrukcja_wyboru=case

indeks_wyboru of
element_l_wyboru

{; element_l_wyboru} [;]

end

element_l_wyboru

=

lista_stałych_wyboru

:

instrukcja

indeks_wyboru = wyrażenie

case dzisiaj.miesiąc of
1, 3, 5, 7, 8, 10, 12: i := i+31;
4, 6, 9, 11: i := i+30;
2: if przestępny(dzisiaj.rok)

then i := i+29 else i := i+28

end

case ...

begin ...
end

 

case ...
end

end

i ?

i=1

i=2 i=3

i=4

Instrukcje iteracyjne

•

Instrukcja iteracyjna powoduje wielokrotne

wykonanie pewnej grupy instrukcji. Jeżeli liczba

powtórzeń jest znana z góry w danym punkcie

programu, to zwykle używa się postaci zwanej

instrukcją "dla", a w przeciwnym razie instrukcji

"dopóki" (gdy powtarzanie ma przebiegać aż do

załamania się pewnego warunku, tj. do chwili

gdy warunek osiągnie wartość false) lub

instrukcji "powtarzaj" (gdy powtarzanie ma

przebiegać aż do osiągnięcia pewnego

warunku, tj. do chwili gdy warunek zmieni

wartość na true).

Instrukcja „dopóki”

instrukcja_dopóki = while wyrażenie_log

do instrukcja

while not eof do
begin

while not eoln do
begin

read(zn);

if zn in litery then licznik[zn] :=
licznik[zn]+1
end;
readln

end;

warunek

ciało
petli

Instrukcja „powtarzaj”

instrukcja_powtarzaj = repeat ciąg_instrukcji

until wyrażenie_log

repeat

repeat
read(zn);
if

ord(zn)>=ord('A')

and

ord(zn)<=ord('Z') then inc(licznik[zn])
until eoln;
readln;

until eof;

warunek

cialo
petli

Instrukcja „dla”

instrukcja_dla = for zmienna_sterująca :=

wartość_początkowa (to|downto)
wartość_końcowa do instrukcja

for i:=1 to n do

begin
for j:=1 to m do
begin
suma := suma + A[i,j];
write(A[i,j], ' ')
end;
writeln;

end;

cialo
petli

obliczenie

liczby

przebiegów

Instrukcja wiążąca

•

Instrukcja wiążąca dotyczy typów

rekordowych. Jej użycie pozwala

na wygodniejsze odwoływanie się

do pól zmiennej rekordowej i

zwiększa czytelność programu.

•

Umieszczenie zmiennej

rekordowej na liście po symbolu

with oznacza, że do pól tej

zmiennej można odwoływać się

wewnątrz instrukcji wiążącej za

pomocą samych identyfikatorów

pól

•

Identyfikatory te są traktowane w

instrukcji wewnętrznej jako

zmienne.

instrukcja_wiążąca

=

with

lista_zmiennych_rekordowych

do instrukcja

;

if dzisiaj.miesiąc = 12 then

begin
dzisiaj.miesiąc := 1;
dzisiaj.rok := dzisiaj.rok +1
end

else dzisiaj.miesiąc :=dzisiaj.miesiąc +1;

with dzisiaj do

if miesiąc = 12 then
begin
miesiąc := 1;
rok := rok+1
end
else

miesiąc:=miesiąc+1;

Procedury i funkcje

•

Rozwiązując bardziej złożony problem wyodrębnia się zwykle

pewne jego części, dla których formułuje się rozwiązania

oddzielnie. Można przy tym albo najpierw rozwiązywać

podproblemy, a następnie łączyć je w całości (podejście

występujące, zwane też projektowaniem syntetycznym, ang.

bottom-up), albo też od-wrotnie, tzn. formułować rozwiązanie

całego zagadnienia w terminach nie rozpatrzonych jeszcze dotąd

części, a dopiero później schodzić na niższy poziom szczegółowości

(podejście zstępujące, zwane też projektowaniem analitycznym,

ang. top-down). W programowaniu strukturalnym stosuje się
zwykle to drugie podejście.

–

Procedura a funkcja (procedury/funkcje standardowe)

–

Wywołanie procedury/funkcji

–

Parametry formalne i aktualne

–

Typy parametrów

Obiekty globalne i lokalne

Deklarowanie procedur i

funkcji

deklaracja_procedury = nagłówek_procedury ; blok_procedury|

nagłówek_procedury ; dyrektywa|
identyfikacja_procedury ; blok_procedury

nagłówek_procedury = procedure identyfikator [lista_param_formal]
identyfikacja_procedury = procedure identyfikator
blok_procedury = blok
blok = część_deklarująca_etykiety

część_definiująca_stałe
część_definiująca_typy
część_deklarująca_zmienne
część_deklarująca-procedury_i_funkcje
część_operacyjna

nagłówek_funkcji = function identyfikator [lista_param_formal]

: typ_wyniku

typ_wyniku = id_typu_prostego|id_typu_wskaźnikowego
blok_funkcji = blok
część_operacyjna = instrukcja_złożona

Deklarowanie procedur i funkcji

(c.d.)

function f (x: real): real;

begin
if x = 0 then
begin
writeln('Funkcja f jest nieokreślona w punkcie

0');
f := 999
end
else

f := sin(pi/x) - 0.5

end

Przekazywanie

parametrów

lista_parametrów_formalnych = ( sekcja_parametrów_formalnych

{ ; sekcja_parametrów_formalnych} )

sekcja_parametrów_formalnych =

specyfikacja_parametrów_przekazywanych_przez_wartość|
specyfikacja_parametrów_przekazywanych_przez_zmienną|
specyfikacja_parametrów_przekazywanych_przez_procedurę|
specyfikacja_parametrów_przekazywanych_przez_funkcję

 
specyfikacja_parametrów_przekazywanych_przez_wartość =

lista_identyfikatorów : identyfikator_typu

specyfikacja_parametrów_przekazywanych_przez_zmienną =

var lista_identyfikatorów : identyfikator_typu

specyfikacja_parametrów_przekazywanych_przez_procedurę =

nagłówek_procedury

specyfikacja_parametrów_przekazywanych_przez_funkcję =

nagłówek_funkcji

Przekazywanie

parametrów (c.d.)

function silnia1 (n: integer): integer;
var i: integer;
begin
silnia := 1;
if n>1 then

for i:=1 to n do
silnia := silnia * n

end;
Project11

Przekazywanie

parametrów (c.d.)

function silnia2 (n: integer): integer;
{wersja rekurencyjna}
begin
if n = 0 then silnia2 := 1
else silnia2 := n * silnia2(n - 1)
end;
 

procedure silnia (n: integer; var wynik: integer);

begin
wynik := 1;
while n>1 do

begin

wynik := wynik * n;
n := n -1
end

end;

Przekazywanie

parametrów (c.d.)

function super_silnia (function silnia (n: integer): integer;
nn: integer; echo: Boolean): integer;
var wynik: integer;
begin
if nn < 0 then writeln('Błędny parametr)
else

begin

wynik := silnia(nn);
if echo then writeln(nn, '! = ', wynik);
super_silnia := wynik
end
end

Mnożenie macierzy

kwadratowych

program MMK (input,

output);

const

n = 4;

{stopień

macierzy}

type

M = array [1..n, 1..n] of
real;

var

i, j, k: 1..n;
a, b, c: M;
r: real;

procedure czytajM (var A: M);
{czytanie wraz z kopiowaniem}
const

tekst = 'Macierz danych: ';

var

i, j: 1..n;
s: real;

begin {elementy macierzy są czytane

wierszami}

writeln(tekst);
for i:=1 to n do
begin
for j:=1 to n do
begin
read(s); write(s:8:2);
A[i,j]:=s
end
writeln
end
writeln

end {czytajM}

Mnożenie macierzy (c.d.)

begin {część operacyjna programu}
czytajM(a);
czytajM(b);
writeln('Macierz wynikowa: ');
for i:=1 to n do
begin
for j:=1 to n do
begin
r:=0;
for k:=1 to n do

r:=r + a[i,k] * b[k,j];

c[i,j]:=r;
write(r:8:2)
end
writeln
end
writeln
end.

Program „spóźnienia” (1)

program spóźnienia (input, output);
label

13;

type

dzień_rob = (pon, wt, sr, czw, pt);
dni_rob = set of dzień_rob;
licznik = integer;
zestaw_sp = array [dzień_rob] of licznik;
płeć = (kob, męż);

var
k_sp, m_sp: zestaw_sp;

{kobiece spóźnienia, męskie ...}

k_dni_sp, m_dni_sp: dni_rob; {kobiece dni spóźnień, męskie...}
p: płeć;

nr: integer;

liczba_sp: licznik;

d: dzień_rob;

zn: char;

 
procedure blędne_dane (nr_karty: integer);
begin
writeln('---Karta nr', nr_karty:5,' jest niepoprawna');
goto 13
end;

Program „spóźnienia” (2)

procedure max_sp(var dni_max: dni_rob; zest: zestaw_sp);
{procedura wyznacza dni maksymalnej liczby spóźnień}
var
d: dzień_rob;
max_s, s: licznik;
begin
dni_max:=[pon]; max_s:=zest[pon];
for d:=wt to pt do
begin
s:=zest[d];
if s=max_s then dni_max:=dni_max + [d]
else

if s>max_s then

begin
max_s:=s; dni_max:=d
end
end
end

Program „spóźnienia” (3)

procedure wydruk (dni_max: dni_rob;

pł: płeć);

var

d: dzień_rob;

begin
if p`l = kob then write (' Kobiety')
else

write (' Mężczyźni');

writeln(' najczęściej spóźniają się w: ');
for d:= pon to pt do

if d in dni_max then

case d of
pon:

write(' poniedziałki');

wt:

write(' wtorki')

œr:

{itd.}

end;
writeln
end;

begin {część

operacyjna
programu};

for d:=pon to pt do
begin
ksp[d]:=0; msp[d]:=0;
end {inicjacji};
nr := 0;
writeln('Kopiowanie

danych wejściowych:');

Program „spóźnienia” (4)

while not eof do
begin
nr:=nr+1;

read(zn);

while (zn = ' ') and not eof do

read(zn);

{pomijanie spacji}

write(zn);
if not eof then

if zn in ['k', 'm'] then

begin
if zn='k' thenp:=kob
else p:=mê¿;
for d:=pon to pt do
begin
read(liczba_sp);
write(liczba_sp: 5);
if p=kob then

k_sp[d]:=k_sp[d]+liczba_sp

else m_sp[d]:=m_sp[d]+liczba_sp
end
writeln
end
else b³êdne_dane(nr);
end {wczytywania danych};
writeln('WYNIKI BADAŃ');

writeln;

max_sp(k_dni_sp, k_sp);

wydruk(k_dni_sp, kob);

max_sp(m_dni_sp, m_sp);

wydruk(m_dni_sp, męż);

13:
end.

Program „grafika” (1)

program grafika (wyk);
const

znak = '*';

var

min_x, max_x, gest_x, min_y, max_y, gest_y:

real;
wyk: text;

 
function fun (x: real): real;
const

pi = 3.14;

begin
fun:= sin(x + pi/2)
end;

Program „grafika” (2)

procedure ośOY (min_y, max_y, gest_y:

real);

var
i, liczba_skoków, skok: integer;
akt_wart: real;
begin
liczba_skoków := round((max_y -

min_y)/gest_y);

skok:=round(OY/liczba_skoków);
write(wyk, min_y: 28:2);
akt_wart:=min_y+gest_y;
while akt_wart <= max_y do
begin
write(wyk, akt_wart: skok:2);
akt_wart:=akt_wart+gest_y;
end;

writeln(wyk);
if skok>24 then skok:=24;
write(wyk, ' ':25 - skok);
for i:=1 to liczba_skoków

do write(wyk, ']': skok);

writeln(wyk); write(wyk,'

':25);

for i:=1 to OY do

write(wyk, '-');

writeln(wyk);
end;

Program „grafika” (3)

begin {część operacyjna procedury wykres}
page(wyk);
writeln(wyk, Wykres funkcji sin(x+pi/2)': 60);

writeln(wyk);

przyrost:=OY/(max_y - min_y);
oœOY(min_y, max_y, gest_y);
arg:=min_x;

{tworzenie osi OX oraz zaznaczanie wartości funkcji}

while arg<max_x do
begin
wart:=f(arg);
write(wyk, ' ':10, arg:10:5, ' -I');
if (wart<min_y) or (wart> max_y) then
write(wyk, 'R'); {znak R oznacza wyjście poza zakres osi OY}
else

write(wyk, znak: round((wart-min_y)*przyrost));

arg:=arg+gest_x;
writeln(wyk);
end
end;

Program „grafika” (4)

begin {część operacyjna}
rewrite(wyk);
min_x:=0.0;

max_x:=10.0; gest_x:=0.1;

min_y:=-1.0;

max_y:=1.0

gest_y:=0.1;

wykres(fun, min_x, max_x, gest_x, min_y,

max_y, gest_y)

end.

Program „drzewo” (1)

program drzewo_identyfikatorów (output);
type
alfa = array [1..8] of char;
wsk = ^drzewo;
drzewo =

record

nazwa: alfa;
{inne atrybuty identyfikatora}
lewe, prawe: wsk
end;
opis_ident =

record

id: alfa;
{inne atrybuty identyfikatora}

end;

var
tabl, p: wsk;
opis: opis_ident;

Program „drzewo” (2)

procedure wprowadź(fop: opis_ident);
var
jest, na_lewo: Boolean;
p, q, r: wsk;
begin
new(p);
with p^ do
begin
lewe:=nil; praw:=nil;
nazwa:=fop.id
end; {inicjacji nowoutworzonego węzła}
jest:=false;
q:=tabl;
if q=nil then tabl:=p

else

begin
repeat
r:=q;
if fop.id = q^.nazwa then jest:=true
else
if fop.id<q^.nazwa then
begin
q:=q^.lewe; na_lewo:=true;
end
else
begin
q:=q^.prawe; na_lewo:=false;
end
until (q=nil) or jest;
if jest then dispose(p)
else
if na_lewo then r^.lewe:=p
else r^.prawe:=p
end

end {wprowadź};

Program „drzewo” (3)

procedure szukaj(fid: alfa; var

pf:wsk);

var
p: wsk;
jest: Boolean;
begin
jest:=false;
p:=tabl;

while (p<>nil) and not jest do
if fid=p.nazwa then jest :=true
else
if fid<p.nazwa then p:=p.lewe
else p:=p.prawe;

fp:=p
end {szukaj};

begin {część operacyjna}
tabl:=nil;
opis.id:='integer ';

wprowadź(opis);

opis.id:='real

';

wprowadź(opis);

opis.id:='char

';

wprowadź(opis);

opis.id:='text

';

wprowadź(opis);

opis.id:='false

';

wprowadź(opis);

opis.id:='true

';

wprowadź(opis);

opis.id:='get

';

wprowadź(opis);

opis.id:='put

';

wprowadź(opis);

opis.id:='x

';

wprowadź(opis);

opis.id:='tabl

';

wprowadź(opis);

{ ... }
szukaj('true

', p);

if p=nil then writeln('Nie ma identyfikatora ''true'' ')
else writeln('Jest ''true'' ');
end.