Jak powstaje program komputerowy?

1 / 18
PROGRAMOWANIE
2 / 18
PROGRAMOWANIE
Jak powstaje program komputerowy?
Języki niskiego poziomu (ang. low-level language) – zapisane w postaci zdefiniowanych symboli
1. Etapy tworzenia programu.
Języki wysokiego poziomu (ang. high-level language) – rozbudowane pod względem składniowym
(ang. assembly language) i ustalonej składni odpowiedniki rozkazów procesora;
przejście do postaci „maszynowej” umoŜliwia program tłumaczący – tzw. asembler.
instrukcje (słowa kluczowe, operatory, …) z których kaŜda odpowiada zwykle większej liczbie
rozkazów procesora;
spośród dość duŜej ilości moŜemy wyróŜnić: C, C++, Pascal, FORTRAN (FORmula TRANslator),
COBOL (COmmon Business Oriented Language), ALGOL (ALGOrythmic Language, ALGebraic
Oriented Language), Basic (Beginner’s All-purpose Symbolic Instruction Code), …;
Java, Java Script, Perl, PHP, … - języki „internetowe” i skryptowe;
Delphi, Kylix (Pascal), C++ Builder, Visual C++ (C++), Visual Basic (Basic), … - języki „wizualne”
oparte na składni standardowego języka.
Algorytm
Program (kod) źródłowy
*
(.pas, .pp, .c, .cpp, …)
(.ppw, .h, …)
3. Podstawowe pojęcia.
a) Kompilacja, interpretacja, translacja.
Kompilacja
Plik binarny
Łączenie
(konsolidacja)
Program (kod) wynikowy
KaŜdy program zapisany w języku niskiego bądź wysokiego poziomu naleŜy przetłumaczyć na język
maszynowy. W procesie tym – ogólnie nazywanym kompilacją – tłumaczone są najpierw wszystkie
instrukcje, aby następnie uruchomić cały program. Jeśli jednak mamy do czynienia z sytuacją, w której
kaŜda instrukcja jest tłumaczona i zaraz potem wykonywana to taki sposób nazywamy interpretacją.
Odpowiednio teŜ określamy programy tłumaczące jako kompilator i interpreter.
Obydwa powyŜsze procesy jak równieŜ programy określane są jako translacja (kompilacja lub
interpretacja) oraz translator (kompilator lub interpreter).
(.ow, .obj, .o, …)
Binarne pliki nagłówkowe, moduły
(.ow, .aw, .o, .a, .obj, .lib, …)
b) Syntaktyka i semantyka.
Syntaktyka (składnia) języka programowania to zbiór elementów (słowa kluczowe, pojedyncze lub
podwójne znaki, …) oraz reguł stosowanych do tworzenia instrukcji („zdań”).
Jeden prosty błąd w składni uniemoŜliwia przeprowadzenie kompilacji programu.
W momencie, gdy składnia jest prawidłowa (kompilacja przebiegła prawidłowo) a jednak program nie
daje oczekiwanych wyników mamy do czynienia z niepoprawną semantyką programu. Mówimy
wówczas o błędach „logicznych” programu.
(.exe, …)
Rys. A. Od algorytmu do gotowego programu.
*
Program (kod) źródłowy – zapisany (na podstawie algorytmu) tekst programu przy uŜyciu składni
wybranego języka programowania.
Program (kod) wynikowy – nazywany równieŜ kodem maszynowym lub wykonywalnym, plik
zawierający rozkazy (instrukcje, polecenia) gotowe do wykonania przez procesor.
Kompilacja (ang. compilation) – tłumaczenie kodu źródłowego na kod binarny, którego postać zaleŜy
od systemu operacyjnego.
Łączenie (ang. link editing, linking) – łączenie pliku programu głównego z plikami nagłówkowymi,
modułami w wyniku czego, powstaje gotowy do uruchomienia program wynikowy;
wszystkie łączone pliki występują w postaci binarnej.
2. Języki programowania.
Wśród wielu istniejących języków programowania moŜemy wyróŜnić kilkanaście z umownym
podziałem na poziomy:
Język maszynowy – przedstawione liczbowo (w kodzie dwójkowym lub szesnastkowym) lub
zakodowane znakowo rozkazy gotowe do odczytania i wykonania przez procesor;
kaŜdy procesor posiada listę rozkazów (od kilkunastu do kilkuset), które potrafi wykonać.
*
Przed właściwą kompilacją dokonywana jest tzw. kompilacja wstępna – prekompilacja (ang.
preprocessing). Jednym z jej zadań jest dołączenie do kodu źródłowego plików nagłówkowych, modułów
(.ppw, .h, …) przechowujących deklaracje standardowych funkcji i procedur, z których nasz program
będzie korzystał. Innym zadaniem kompilacji wstępnej jest zastąpienie wszelkich napisów
(deklarowanych na początku programu jako stałe) ich wartościami.
3 / 18
PROGRAMOWANIE
4 / 18
PROGRAMOWANIE
Środowisko tworzenia programów.
Struktura i podstawowe instrukcje programu.
1. Tworzenie i kompilacja z wiersza poleceń.
1. Przykładowy program.
Po utworzeniu pliku z kodem źródłowym (w dowolnym „prostym” edytorze tekstu) wydajemy
polecenie uruchomienia kompilatora „zewnętrznego” według poniŜszego schematu:
kompilator program.pas <Enter>
Szczegóły (w systemie Windows) mogą przedstawiać się następująco:
uruchomienie wiersza poleceń:
Start | Programy | Akcesoria | Wiersz polecenia
przejście do katalogu z programem:
>cd ”c:\Document and Settings\user\Moje Dokumenty\programy <Enter>
otwarcie pustego pliku program.pas w edytorze edit:
>edit program.pas <Enter>
wpisanie kodu źródłowego programu
tłumaczenie kodu źródłowego na kod wynikowy (program.exe):
>fpc program.pas <Enter>
Po wykonaniu powyŜszych poleceń w domyślnym katalogu znajdziemy plik program.exe, który
moŜemy uruchomić przez wpisanie nazwy i zatwierdzenie klawiszem <Enter>. Na ekranie powinniśmy
zobaczyć efekt działania naszego programu.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var x,y: integer;
BEGIN
writeln(’AUTOKALKULATOR’);
writeln;
write(’Podaj pierwszą liczbę: ’);
readln(x);
write(’Podaj drugą liczbę: ’);
readln(y);
writeln;
writeln(’Suma: ’,x+y);
writeln(’RóŜnica: ’,x-y);
writeln(’Iloczyn: ’,x*y);
writeln(’Iloraz: ’,x/y:0:2);
writeln(’Dzielenie całkowite: ’,x div y);
writeln(’Reszta z dzielenia: ’,x mod y);
readln;
END.
2. IDE – zintegrowane środowisko programowania.
a) Przygotowanie IDE (ang. Integrated Development Environment):
(na przykładzie środowiska FreePascal – FPC 2.0.0)
- instalacja programu (fpc-2.0.0.i386-win32.exe);
- utworzenie w wybranym miejscu (np. na Pulpicie) katalogu do przechowywania własnych plików
konfiguracyjnych i tworzonych programów oraz skopiowanie ścieŜki dostępu do tego katalogu;
- utworzenie w wybranym miejscu (np. na Pulpicie) oraz konfiguracja właściwości skrótu do programu
fp.exe (karta: Skrót - Rozpocznij w: „skopiowana wcześniej ścieŜka dostępu” oraz Zmień ikonę…,
karta: Opcje - Opcje wyświetlania: Pełny ekran, karta: Układ - Rozmiar buforu ekranu: Wysokość: 25).
2. Podstawowe elementy programu.
a) Początek (2) i koniec (17) programu.
b) Deklaracja zmiennych (1):
Po słówku var – rozpoczynającym deklarację – umieszczamy nazwy zmiennych (x, y) a następnie
określamy typ danych (integer), czyli zakres wartości, jakie będą mogły przyjmować zmienne.
Dostępne typy danych liczbowych zawierają poniŜsze tabele.
Typ
Byte
Shortint
Word
Integer
Longint
Liczby całkowite
Zakres
0 . . 255
-128 . . 127
0 . . 65535
-32768 . . 32767
-2147483648 . . 2147483647
Cardinal
Int64
Qword
0 . . 4294967295
-9,2·1018 . . 9,2·1018
0 . . 18,4·1018
Typ
Single
Real (Double)
Liczby rzeczywiste
Zakres*
1,5E-45 . . 3,4E38
5,0E-324 . . 1,7E308
b) Podstawowe operacje w zintegrowanym środowisku:
- otwarcie nowego dokumentu (File | New);
- otwarcie istniejącego dokumentu (File | Open – F3);
- zapisanie dokumentu (File | Save – F2);
- zapisanie dokumentu pod inną nazwą (File | Save as…);
- tłumaczenie, kompilacja programu (Compile | Compile – Alt+F9);
- uruchomienie programu (Run | Run – Ctrl+F9);
- „przechodzenie” między okienkami (Window | Next/Previous – F6/Shift+F6);
- zamknięcie okienka (Window | Close – Alt+F3);
- koniec pracy z programem (File | Exit – Alt+X).
Długość [B]
1
1
2
2
4
4
8
8
Długość* [B]
4 (7-8)
8 (15-16)
5 / 18
PROGRAMOWANIE
Extended
Comp
1,9E-4951 . . 1,1E4932
-2E-64+1 . . 2E63-1
10 (19-20)
8 (19-20)
c) Wypisywanie tekstu oraz wartości zmiennych lub wyraŜeń na standardowe wyjście, czyli
ekran (3-5, 7, 9-15).
6 / 18
PROGRAMOWANIE
Podejmowanie decyzji – instrukcja wyboru „IF…”.
1. Struktura i działanie instrukcji.
d) Odczytywanie danych ze standardowego wejścia, czyli klawiatury (6, 8, 16).
e) Operatory arytmetyczne:
Operator
+
–
*
/
div
mod
Operatory arytmetyczne
Działanie
Dodawanie
Odejmowanie
MnoŜenie
Dzielenie „rzeczywiste”
Dzielenie „całkowite”, np. 9 div 4 = 2
Reszta z dzielenia całkowitego, np. 9 mod 4 = 1
T
IF warunek THEN instrukcja1
ELSE instrukcja2;
warunek
instrukcja1
T
N
instrukcja2
warunek
N
IF warunek THEN instrukcja;
instrukcja
f) Średnik (;) na końcu instrukcji oraz kropka (.) na końcu programu.
g) Zmiana sposobu wyświetlania liczb rzeczywistych:
writeln(’Iloraz: ’,x/y:0:2);
Jeśli warunek jest prawdziwy to wykonywana jest instrukcja umieszczona za słówkiem THEN
(instrukcja1), w przeciwnym wypadku – warunek nieprawdziwy – będzie wykonana instrukcja po
słówku ELSE (instrukcja2). Część instrukcji od słówka ELSE jest opcjonalna.
2. Przykładowy program.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
var l,d,r: integer;
BEGIN
writeln(’PODZIELNOŚĆ LICZB’);
writeln;
write(’Podaj liczbę: ’);
readln(l);
write(’Podaj dzielnik: ’);
readln(d);
writeln;
r:=l mod d;
if r=0 then writeln(’Liczba PODZIELNA’)
else writeln(’Liczba NIEPODZIELNA’);
readln;
END.
3. Elementy programu.
a) Operacja i operator przypisania (:=).
W instrukcjach przypisania wartość stojąca po prawej stronie operatora jest przypisywana do zmiennej
stojącej po jego lewej stronie. Jeśli po prawej stronie znajduje się wyraŜenie to przed przypisaniem
będzie obliczone (np. r:=l mod d).
7 / 18
PROGRAMOWANIE
b) Operacja i operatory porównania:
Operator
=
<>
<
>
<=
>=
Operatory relacji
Działanie
Równy
RóŜny
Mniejszy
Większy
Mniejszy lub równy
Większy lub równy
c) Deklaracja modułów:
Moduł to zewnętrzny plik z opisem dodatkowych funkcji. Dołączenie go do tworzonego przez nas
programu pozwala na korzystanie z tych funkcji. Moduły dołączamy za pomocą słówka uses, po którym
podajemy nazwę modułu. MoŜemy dodać większą ilość modułów rozdzielając ich nazwy znakiem
przecinka. Przykład deklaracji modułu oraz uŜycia niektórych jego funkcji – poniŜej.
uses crt;
...
BEGIN
clrscr; { funkcja do „czyszczenia” ekranu }
...
textcolor(blue); { funkcja do ustalenia koloru tekstu }
...
END.
d) Instrukcja złoŜona:
...
IF r=0 THEN begin
textcolor(red);
writeln(’Liczba...’);
end
else begin
textcolor(blue);
writeln(’Liczba...’);
end;
...
ĆWICZENIA
1. Korzystając z instrukcji „IF…” napisz program, który spośród 3 liczb podanych przez uŜytkownika
wypisze największą (najmniejszą).
2. Uporządkuj rosnąco i wypisz na ekran 3 liczby podane przez uŜytkownika.
8 / 18
PROGRAMOWANIE
Instrukcja wielokrotnego wyboru „CASE…”.
1. Przykładowy program.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
var x,y: integer;
zn: char;
BEGIN
writeln(’PROSTY KALKULATOR’);
writeln;
write(’Podaj pierwszą liczbę: ’); readln(x);
write(’Podaj drugą liczbę: ’); readln(y);
write(’Podaj znak działania (+,-,*,/,d-dziel.całk.,m-reszta…: ’);
readln(zn);
case zn of
’+’ : writeln(’Suma: ’,x+y);
’-’ : writeln(’RóŜnica: ’,x-y);
’*’ : writeln(’Iloczyn: ’,x*y);
’/’ : writeln(’Iloraz: ’,x/y:0:3);
’d’,’D’ : writeln(’Dzielenie całkowite: ’,x div y);
’m’,’M’ : writeln(’Reszta z dzielenia: ’,x mod y);
else writeln(’Podałeś nieprawidłowy znak’);
end;
readln;
END.
2. Opis instrukcji.
Instrukcja case umoŜliwia wybór (tutaj spośród sześciu operacji) polecenia w zaleŜności od wartości
zmiennej (zn) umieszczonej między słowami case i of. Jeśli zmienna zn przyjmie wartość róŜną od
zdefiniowanych (tutaj róŜną od: +,-,*,/,d,D,m,M) wówczas program wykona instrukcję umieszczoną po
słówku else. Zakończenie instrukcji case stanowi słówko end.
Słowo else i występujące za nim polecenie (17) są opcjonalne, tzn. mogą nie wystąpić.
Zmienna, na podstawie której dokonujemy wyboru moŜe być takŜe liczbą całkowitą (ćwicz. 1).
Oprócz pojedynczych znaków (’+’) lub grupy znaków oddzielanych przecinkiem (’d’,’D’)
dozwolone jest takŜe stosowanie zakresu (np.: ’a’..’z’).
3. Typ znakowy.
Zmienna zn jest typu char (2) co oznacza, Ŝe moŜemy w niej przechowywać pojedyncze znaki.
W pamięci komputera zmienne tego typu zajmują 1 bajt.
ĆWICZENIA
1. Zastosuj instrukcję „CASE…” w programie wypisującym informacje o ilości dni podanego przez
uŜytkownika miesiąca (miesiąc podawany jest w postaci liczb arabskich).
2. Na podstawie odpowiednich danych oblicz pola, obwody lub objętości wybranych figur
geometrycznych (co najmniej trzech).
9 / 18
PROGRAMOWANIE
1. Instrukcja „REPEAT…”.
instrukcja(-e)
T
(true /false)
warunek
N
Działanie „pętli” rozpoczyna się od wykonania wszystkich instrukcji zawartych między słówkami
repeat i until. Następnie sprawdzany jest warunek. Jeśli okaŜe się nieprawdziwy (false) to program
wraca na początek pętli i wykonuje instrukcje ponownie. Dzieje się tak do momentu, kiedy warunek
okaŜe się prawdziwy (true). Następuje wówczas przejście do kolejnej instrukcji programu
(umieszczonej za pętlą „REPEAT…”.
Ze względu na sprawdzanie warunku na końcu „pętli”, instrukcja(-e) zawarte pomiędzy słówkami
repeat i until wykonane zostaną co najmniej jeden raz.
2. Instrukcja „WHILE…”.
WHILE warunek
DO
instrukcja(-e);
(true /false)
T
warunek
N
instrukcja(-e)
Tym razem działanie „pętli” rozpoczyna się od sprawdzenia warunku. Jeśli jest prawdziwy (true)
wykonywane są instrukcje umieszczone po słówku DO i program wraca do ponownego sprawdzenia
warunku. W przeciwnym wypadku – warunek nieprawdziwy (false) - pętla kończy działanie
i program przechodzi do dalszej części programu.
Ze względu na sprawdzanie warunku na początku „petli” instrukcja(-e) umieszczone po słówku DO
mogą być zupełnie pominięte.
3. Instrukcja „FOR…”.
FOR i:=wp TO wk DO instrukcja;
FOR i:=wk DOWNTO wp DO instrukcja;
(1)
(2)
PROGRAMOWANIE
Działanie pętli FOR sprowadza się do wykonania instrukcji umieszczonej po słówku DO tyle razy ile jest
kolejnych wartości od wp do wk. Wartości te zmieniają się automatycznie o 1, rosnąco - jeśli uŜyjemy
słówka TO (1), malejąco – jeśli uŜyjemy słówka DOWNTO (2).
Jeśli zmienna sterująca i jest typu znakowego (char) to przyjmuje ona kolejne wartości z zestawu
znaków ASCII.
Powtarzanie operacji – opis instrukcji.
REPEAT
...
instrukcja(-e);
...
UNTIL warunek;
10 / 18
11 / 18
PROGRAMOWANIE
Powtarzanie operacji w programach.
1. Powtórzenie wykonania programu w zaleŜności od decyzji uŜytkownika.
1
2
3
4
5
6
7
8
9
10
11
...
var odp: char;
BEGIN
REPEAT
...
instrukcja(-e);
...
write(’Koniec programu?(t/n): ’);
readln(odp);
UNTIL (odp=’t’) or (odp=’T’)
END.
2. Największa i najmniejsza spośród wprowadzanych liczb.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var liczba, max, min: integer;
BEGIN
writeln(’MAX I MIN’); writeln;
writeln(’Wprowadzaj liczby (”0” – kończy wprowadzanie):’);
readln(liczba);
max:=liczba;
min:=liczba;
WHILE liczba<>0 DO begin
if liczba>max then max:=liczba else
if liczba<min then min:=liczba;
readln(liczba);
end;
writeln(’Max = ’,max);
writeln(’Min = ’,min);
readln;
END.
3. Suma i średnia arytmetyczna.
1
2
3
4
5
6
7
8
9
10
11
12
var s,liczba: integer;
i: byte;
BEGIN
writeln('SUMA I SREDNIA ARYTMETYCZNA');
writeln(' Wprowadzaj kolejne liczby ("0" - konczy wprowadzanie');
s:=0; i:=1;
write('x',i,' = '); readln(liczba);
WHILE liczba<>0 DO begin
s:=s+liczba;
i:=i+1;
write('x',i,' = '); readln(liczba);
end;
12 / 18
13
14
15
16
17
PROGRAMOWANIE
writeln;
writeln('
Suma = ',s);
writeln('Srednia = ',s/i:0:2);
readln;
END.
4. Wypisywanie liczb.
a) liczby parzyste i nieparzyste:
FOR i:=1 TO 100 DO write(i*2,’ ’);
FOR i:=50 DOWNTO 1 DO write(i*2-1,’ ’);
b) liczby Fibonacciego:
1 1 2 3 5 8 13 21 34 55 …
1
2
3
4
5
6
7
8
9
10
11
12
13
14
var n,i: integer;
a,b,s: longint;
BEGIN
writeln('LICZBY FIBONACCIEGO'); writeln;
write('Podaj ilosc liczb do wypisania: '); readln(n);
a:=0; b:=1;
writeln; write(b,' ');
FOR i:=1 TO n-1 DO begin
s:=a+b;
write(s,' ');
a:=b; b:=s;
end;
readln;
END.
5. Rysowanie choinki z gwiazdek.
1
2
3
4
5
6
7
8
9
10
11
var i,wrs,gw: integer;
BEGIN
writeln('CHOINKA Z GWIAZDEK'); writeln;
write('Podaj wysokosc (ilosc wierszy) choinki: '); readln(wrs);
writeln;
FOR i:=1 TO wrs DO begin
FOR gw:=1 TO i DO write('*');
writeln;
end;
readln;
END.
6. Znaki i ciągi znaków.
a) litery alfabetu oraz znaki kodu ASCII:
var z: char; i: byte;
...
FOR z:=’a’ TO ’z’ DO write(z,’ ’);
13 / 18
PROGRAMOWANIE
writeln; writeln;
FOR i:=0 TO 255 DO write(char(i),’ ’);
b) tekst „rozstrzelony”:
1
2
3
4
5
6
7
8
9
var s: string;
i: byte;
BEGIN
writeln('TEKST ROZSTRZELONY'); writeln;
writeln('wpisz dowolny tekst (do 250 znakow):'); writeln;
readln(s); writeln;
FOR i:=1 TO length(s) DO write(s[i],' ');
readln;
END.
14 / 18
PROGRAMOWANIE
Przechowywanie danych w tablicach.
1. Definicja i rodzaje tablic.
Tablica to zbiór danych tego samego typu (mat. wektor, macierz).
Deklaracje oraz wpisywanie wartości do komórek tablicy przedstawiają poniŜsze przykłady.
a) Tablice jednowymiarowe.
var tl: array[1..5] of byte;
1
tl[4]:=35;
2
3
tl
4
5
35
var tz: array[1..5] of char;
1
tz[3]:=’a’;
2
tz
3
4
5
4
a
var tz: string[5];
ĆWICZENIA
1. Podaj ile liczb zostanie wypisanych w zadaniu 4a.
2. Korzystając z przykładu umieszczonego w punkcie 5, napisz program rysujący „pełną” choinkę..
tz:=’ala’;
tz
1
2
3
a
l
a
5
var ts: array[1..2] of string[3];
1
ts[2]:=’ola’;
2
tz
1
2
3
4
o
l
a
1
2
3
4
write(’Imie: ’); readln(ts[2]);
Dla ułatwienia pracy z tablicami często umieszcza się wielkość tablicy pod określoną nazwą w części
definicji stałych, np.:
const max=50;
var tl: array[1..max] of integer;
b) Tablice dwuwymiarowe.
var dtl: array[1..3,1..5] of integer;
1
dtl[1,4]:=35;
dtl[2,2]:=-32;
1
2
3
2
3
4
5
35
-32
2. Wartości początkowe tablic.
Wartości początkowe elementom tablic moŜemy nadać w części deklaracji stałych, np.:
const tl: array[1..5] of byte = (1,2,3,4,5);
const samogloska: array[1..6] of char = (’a’,’e’,’i’,’o’,’u’,’y’);
const dtl: array[1..2,1..3] of byte = ((1,3,5),(2,4,6));
Wartości te mogą być zmieniane w trakcie działania programu w odróŜnieniu od stałych
„samodzielnych”, np.:
const max=3;
gdzie stała max nie moŜe przyjmować w trakcie działania programu innych wartości.
15 / 18
PROGRAMOWANIE
16 / 18
PROGRAMOWANIE
Podprogramy – procedury i funkcje.
Moduł – zbiór procedur, funkcji oraz zmiennych.
1. Ogólna definicja procedury i funkcji.
1. Definiowanie modułu.
PROCEDURA
procedure nazwa_p(parametry);
deklaracje;
begin
instrukcje;
end;
FUNKCJA
function nazwa_f(parametry):typ_wyniku;
deklaracje;
begin
instrukcje;
nazwa_f:=wyraŜenie;
end;
Zarówno w przypadku procedury jak i funkcji wystąpienie parametrów (argumentów) oraz
ewentualnych deklaracji jest opcjonalne.
2. Definicja i wywołanie podprogramów.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
uses crt;
procedure start(t:string[80]);
begin
clrscr;
writeln(t); writeln;
end;
function silnia(n:byte):longint;
var s:longint; i:byte;
begin
s:=1;
for i:=1 to n do s:=s*i;
silnia:=s;
end;
var liczba: byte;
BEGIN
start('OBLICZENIA');
write('Podaj liczbę naturalną: '); readln(liczba);
writeln(’Silnia z ’,liczba,’ = ’,silnia(liczba));
readln;
END.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
unit modul;
interface
uses crt;
procedure start(t:string[80]);
function silnia(n:byte):longint;
function potega(x,y:byte):longint;
implementation
procedure start(t:string[80]);
begin
clrscr;
writeln(t); writeln;
end;
function silnia(n:byte):longint;
var s:longint; i:byte;
begin
s:=1;
for i:=1 to n do s:=s*i;
silnia:=s;
end;
function potega(x,y:byte):longint;
var p:longint; i:byte;
begin
p:=x;
for i:=1 to y-1 do p:=p*x;
potega:=p;
end;
end.
Po wpisaniu treści modułu zapisujemy go pod taką nazwą, jaką umieściliśmy po słówku unit (program
sam dopisze rozszerzenie .pas). Następnie dokonujemy kompilacji. Jeśli nie będzie błędów po tej
operacji zostanie utworzony na dysku plik o rozszerzeniu .ppu. Jest to standardowe rozszerzenie nazw
plików modułów środowiska FreePascal (w środowisku TurboPascal skompilowane moduły otrzymują
rozszerzenie .tpu). Od tego momentu moduł jest gotowy do uŜycia. Modułu nie uruchamiamy –
poniewaŜ nie jest on programem – tylko dołączamy do wybranego programu przy uŜyciu polecenia
uses. PoniŜej sposób dołączenia modułu do programu i korzystanie z zawartych w nim podprogramów.
2. Program z wykorzystaniem modułu.
Parametry podawane przy definicji procedury lub funkcji nazywamy parametrami formalnymi (2,7),
natomiast parametry podane w momencie wywołania nazywamy parametrami aktualnymi (16,18).
Jeśli deklarujemy zmienne w procedurze lub funkcji to nazywamy je zmiennymi lokalnymi; zachowują
one swoje znaczenie tylko w obrębie danej procedury lub funkcji. Zmienne deklarowane poza
podprogramami nazywane są zmiennymi globalnymi i obowiązują zarówno w programie głównym jak
i we wszystkich procedurach i funkcjach.
1
2
3
4
5
6
7
8
9
uses modul;
var liczba,pot: byte;
BEGIN
start('OBLICZENIA');
writeln(’SILNIA’);
write('Podaj liczbę naturalną: '); readln(liczba);
writeln(’Silnia z ’,liczba,’ = ’,silnia(liczba));
writeln; writeln(’POTĘGOWANIE’);
write('Podaj liczbę naturalną: '); readln(liczba);
17 / 18
10
11
12
13
PROGRAMOWANIE
write(’Podaj potęgę: ’); readln(pot);
writeln(liczba,’ do potęgi ’,pot,’ = ’,potega(liczba,pot));
readln;
END.
18 / 18
PROGRAMOWANIE
Pliki – odczytywanie i zapisywanie danych.
1. Podstawowe operacje na plikach tekstowych.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var d,w: text;
l: integer;
dodatnie, ujemne: byte;
BEGIN
writeln('ZLICZANIE DODATNICH I UJEMNYCH LICZB'); writeln;
assign(d,’dane.txt’);
assign(w,’wyniki.txt’);
reset(d);
rewrite(w);
while not eof(d) do begin
readln(d,l);
if l>=0 then dodatnie:=dodatnie+1 else ujemne:=ujemne+1;
end;
writeln(w,’Liczb dodatnich: ’,dodatnie);
writeln(w,’Liczb ujemnych: ’,ujemne);
close(d);
close(w);
END.
W programie deklarujemy zmienne typu text (1), aby później skojarzyć je z właściwymi plikami za
pomocą instrukcji assign (6,7). Następnie otwieramy plik do odczytywania danych – reset (8) oraz
tworzymy nowy plik do zapisywania danych – rewrite (9). W trakcie odczytywania danych z pliku
stosujemy standardową instrukcję readln (11), której pierwszym parametrem jest odpowiednia
zmienna plikowa. To samo dotyczy instrukcji zapisywania danych do pliku – writeln (14,15).
W trakcie wykonywania operacji na plikach przydatną moŜe okazać się instrukcja sprawdzająca
osiągnięcie końca pliku – eof (10). Funkcja ta zwraca wówczas wartość true.
Po ukończeniu wszelkich operacji na plikach zamykamy je poleceniem close (16,17).