Wstęp
do programowania
Wykład 5  procedury i funkcje
Podprogramy
Często wygodnie jest zapisać część
programu jako podprogram czyli jako
funkcje
lub
Procedurę
Podprogram - wyodrębniona część programu, stanowiąca
całość (tzw.blok), posiadająca nazwę
i ustalony sposób wymiany informacji z pozostałymi
częściami programu.
Cechy
Funkcje i procedury.
umieszcza się je w części deklaracyjnej programu
lub w odrębnej jednostce kompilacyjnej
funkcja zazwyczaj operuje na pewnych
argumentach (nie modyfikując ich) i zwraca
pewną obliczoną wartość (jedną)
procedura zazwyczaj operuje na pewnych
argumentach, może je modyfikować i w ten
sposób zwrócić pewną wyliczoną wartość lub
wartości
Deklaracja procedury
Procedura - podprogram wykonujący jedną lub więcej czynności i
zwracający od jednego do kilku wyników;
lub nie zwracająca żadnego wyniku
nazwa używana jest w charakterze instrukcji w programie.
Procedure nagłółwek_proc
nagłówek
Cześć deklaracyjna
procedury
{const type var  zmienne
Część
lokalne}
deklaracyjna
Begin
Ciąg instrukcji
begin
end;
Blok
....
ciąg instrukcji
procedury
Wywołanie procedury
{użycie jako instrukcja w
End;
programie}
Deklaracja procedury
Nagłówek procedury
Procedure nazwa_procedury (lista parametrów formalnych);
Procedure nazwa_procedury (var lista; parametrów; formalnych);
Wywołanie
nazwa_procedury ( lista, parametrów, aktualnych);
" Lista parametrów formalnych pozwala w sposób jawny przekazywać dane do
procedury lub funkcji.
" W wywołaniu podprogramu listę parametrów formalnych zastępuje lista
parametrów aktualnych
" Parametr aktualny musi być takiego samego typu jak odpowiadający mu na
liście parametr formalny.
" Parametry aktualne w wywołaniu podprogramu oddzielone są przecinkami.
Deklaracja procedury
Procedure nazwa_procedury (lista parametrów formalnych);
Są dwa sposoby przekazywania parametrów do procedury
Parametry przekazywane przez wartość
(lista parametrów formalnych)=
=(Identyfikator_1: typ1; Identyfikator_2,..., Identyfikator_n :
Typ);
Parametry przekazywane przez zmienną
var lista parametrów formalnych=
= (var Identyfikator_1: typ1 ; var Identyfikator_2,..., Identyfikator_n:
Typ);
procedury
Parametry przekazywane przez wartość:
(przekazywanie w jedną stronę, praca na kopii parametru)
procedure dodaj(a: integer; b: Single);
procedure generator(x: real);
procedure napisy; //procedura bez parametrów
Type Matrix=array[1..5,1..4] of Double;
procedure wypisz(M: Matrix);
// zła deklaracja: procedure wypisz(M: array[1..5,1..4] of Double);
��W wyniku wywołania procedury lub funkcji parametrom formalnym zostaje
przypisana wartość początkowa równa wartościom odpowiednich parametrów
aktualnych.
��Operacje wykonywane w treści funkcji lub procedury wykonywane
są na kopii umieszczonej na stosie i w związku z tym nie powodują zmian
wartości odpowiadających im parametrów aktualnych.
procedury
Parametry przekazywane przez zmienną:
(przekazywanie w obie strony, praca na oryginale parametru)
procedure zapisz(var x: byte);
procedure dodaj(var a: integer; var b: Single);
procedure dodaj(a, b: integer; var c: Single);
Type Matrix=array[1..5,1..5] of byte;
procedure dodajM(A, B : Matrix; var M : Matrix);
��Operacje wykonywane w treści funkcji lub procedury wykonywane są
bezpośrednio na przekazywanych do procedury lub funkcji parametrach
aktualnych.
��Efektem takiego działania jest zmiana wartości parametrów aktualnych po
wywołaniu procedury lub funkcji.
Parametry procedury/funkcji
" Parametry formalne - pojawiają się w nagłówku deklaracji funkcji bądz

procedury i są używane w instrukcjach funkcji lub procedury jak zwykłe
zmienne.
" Liczba parametrów formalnych nie jest ograniczona i ich kolejność
występowania jest dowolna. Parametr formalny jest obowiązkowo
zmienną.
" Parametry aktualne - są parametrami występującymi w bloku, z
którego wywoływana jest funkcja lub procedura i używane są podczas
wywołania procedury lub funkcji.
" Liczba parametrów aktualnych musi być taka sama jak liczba
parametrów formalnych i należy pamiętać o zgodności typów.
Parametrem aktualnym może być wyrażenie, zmienna bądz
stała.
" Wywołanie procedury  polega na wpisaniu nazwy procedury z
odpowiednią listą parametrów aktualnych jako instrukcji programu.
np.: wypisz(a,b,c);
Przykłady procedur
var
a, b :Integer;
program Podpr1;
begin
{$APPTYPE CONSOLE}
uses SysUtils;
a := 1; b := a+1;
www(a, b+1);
procedure www(k, m :Integer);
begin
writeln('a=',a);
writeln('k=',k);
www(a, b+1);
k := k+m;
writeln('k=',k);
writeln('a=',a);
end;
zzz(a, b);
procedure zzz(var k, m :Integer);
writeln('a=',a);
begin
zzz(a, b);
writeln('k=',k);
k := k+m;
writeln('a=',a);
writeln('k=',k);
readln;
end;
end.
var
Procedura z domyślną wartością
parametru wywołania
program Podpr2;
{$APPTYPE CONSOLE}
Procedure demo(const napis:
W Delphi istnieje możliwość podania
string= Wartosc domyslna demo );
domyślnej wartości parametru
Begin
wywołania procedury lub funkcji.
writeln(napis);
poprzez użycie słowa kluczowego
end;
Const w nagłówku procedury
Var s: string;
przed nazwą parametru oraz
begin
podanie jego wartości po znaku =
s:= procedura demo ;
demo(s);
demo;
demo( dowolny napis )
readln;
end.
procedure wypisz(M :matrix);
Przykłady procedur
Var i,k: byte;
wyświetlanie macierzy
begin
for i:=1 to RM do
begin
program Podpr2;
for k:=1 to RM do
{$APPTYPE CONSOLE}
write(M[i,k]:4);
uses SysUtils;
writeln;
Const RM=5;
end;
Type matrix=array[1..RM,1..RM]of
writeln;
Byte;
End;
procedure gener(var M : matrix);
Var A, M : Matrix;
Var i, k :byte; //zmienne lokalne
Begin //cz. wykonawcza
Begin
wypisz(M);
Randomize;
gener(M);
for i:=1 to RM do
wypisz(M);
for k:=1 to RM do
gener(A);
M[i,k]:=random(10);
wypisz(A); readln;
end;
end.
program proc2;
Przykłady procedur {$APPTYPE CONSOLE}
uses sysutils;
zmienne globalne
var zm_globalna :integer;
Procedure proc_glob;
-zmienne globalne
Var zm_lok :Integer;
to zmienne
Begin
zm_lok:=1;
zdefiniowane
zm_globalna:=zm_globalna+1;
przed def. Procedur
writeln('zm_lok=',zm_lok);
użwane wewnątrz
writeln('zm_glob=',zm_globalna);
z możliwością ich
end;
zmiany.
var zm_globalna1 :integer;
begin
Powinno się unikać
zm_globalna:=5;
używania zm.
writeln('zm_glob=',zm_globalna );
Globalnych
proc_glob;
writeln('zm_g=',zm_globalna );// 6
przez używanie
zm_globalna:=9;
zm. Lokalnych i
writeln(zm_globalna ); //9
parametrów
proc_glob; //10
formalnych
writeln(zm_globalna ); //10
i przekazywanie ich
readln;
przez zmienną
END.
Deklaracja Funkcji
Funkcja - podprogram wykonujący jedną lub więcej czynności i
zwracający dokładnie jedną wartość.
nazwa używana jest w charakterze wyrażenia lub instrukcji.
nagłówek funkcji
Część
deklaracyjna
begin
Blok
ciąg instrukcji
funkcji
Result := wyrażenie
end.
Deklaracja Funkcji
Funkcja - podprogram wykonujący jedną lub więcej czynności i
zwracający dokładnie jedną wartość.
" nazwa używana funkcji jest w charakterze wyrażenia lub wartości.
Function nazwa_funkcji : typ_wyniku
//Cześć deklaracyjna
{const type var  zmienne lokalne}
Begin
Function nazwa_funkcji :
Ciąg instrukcji
typ_wyniku
Result := wyrażenie;
Begin
end;
Ciąg instrukcji
nazwa_funkcji := wyrażenie;
end;
Deklaracje funkcji
Nagłówek funkcji
Function nazwa_funkcji (lista; parametrów; formalnych) : typ;
Wywołanie funkcji  polega na wpisaniu nazwy funkcji z
odpowiednią listą parametrów aktualnych w wyrażeniu.
nazwa_funkcji ( lista, parametrów, aktualnych);
" Lista parametrów formalnych pozwala w sposób jawny przekazywać
dane do funkcji.
" W wywołaniu funkcji listę parametrów formalnych zastępuje lista
parametrów aktualnych
" Parametr aktualny musi być takiego samego typu jak odpowiadający
mu na liście parametr formalny.
Zwracanie wyniku przez funkcję
Zwracanie wartości funkcji odbywa się za
pomocą instrukcji Result
Która jest zamienna lokalną:
Result := zwracany_wynik
Wykonanie takiej instrukcji kończy działanie funkcji
(//pascasl -dalsze jej instrukcje, jeśli istnieją, nie będą
wykonywane).
Jeśli typ wyrażenia zwracany_wynik nie zgadza się z typem
zwracanego wyniku podanym w deklaracji funkcji, to
zwracany_wynik jest odpowiednio konwertowany, jeśli jest
to możliwe.
Deklaracje funkcji
Parametry przekazywane przez wartość:
(przekazywanie w jedną stronę)
function dodaj(a: byte; b: single) : single;
Begin
Result:=a+b;
// dodaj:=a+b;
end;
//Wywołania
Var a, x : byte;
b, y : single;
.....
Wynik:=dodaj(x,y);
Writeln(wynik);
Writeln( dodaj(a,b));
Deklaracje funkcji
przekazywanie tablic do funkcji
Type Tablica=array[1..10]of Samllint;
function Iloczyn_skalarny(A,B:Tablica ) : SmallInt;
//Wywołania
Var A, B : Tablica;
wynik : SamllInt;
.....
Wynik:=Iloczyn_skalarny(A,B);
lub
Writeln( wynik= , Iloczyn_skalarny(A,B));
Przykłady funkcji
program Podpr2;
{$APPTYPE CONSOLE} {$O-,Q+,R+}
uses SysUtils;
function suma2(k, m :Integer) : Integer;
Begin
Result := k+m;
Result := Result *2;
//suma2 := suma2*4; //nie polecane
end;
Var a, b, x :Integer;
Begin
x:=suma2(1,4);
Writeln('suma=',x);
A:=2; b:=3;
writeln(suma2(2,3));
writeln(suma2(a,b)); readln;
end.
Wywołanie funkcji
program Podpr3;
{$APPTYPE CONSOLE} {$O-,Q+,R+}
function jaka_wartosc : Integer;
Begin
Result := 1; {niejdnozancze okrerlenie wartosci funkcji}
jaka_wartosc:= 2;
Result :=3 ; //ta wartość zostanie zwrócona
writeln('funkcja  jaka_wartosc ');
end;
Var x :Integer;
Begin
x:= jaka_wartosc; //wywołanie funkcji jak funkcji i zwrot wartości
Writeln('x=',x);
jaka_wartosc ;
readln; //wywołanie funkcji jak procedury, bez zwrotu wartości
Writeln(jaka_wartosc ); readln;
end.
Przeciążanie funkcji
Przeciążanie  wielokrotne
program Podpr4;
Definiowanie funkcji lub
{$APPTYPE CONSOLE} {$O-,Q+,R+}
procedur o tych samych nazwach
różniących się zestawem
function dodaj(a,b :byte) : byte; Overload;
parametrów formalnych
wywołania.
Begin
Result := a+b;
W takim przypadku trzeba
end;
użyć dyrektywy overload
w nagłówku każdej przeciążonej
function dodaj(a,b :string) : string; Overload;
funkcji lub procedury.
Begin
Result := a+b;
Przeciążone funkcje w działają
end;
odpowiednio w zależności
od aktualnych parametrów
Begin
Wywołania.
Writeln('dodaanie liczb=',dodaj( 1, 2 ));
Writeln('dodawanie łancuchow =',
dodaj('1','2'));
readln;
Przykłady funkcji +oper na tablicach
program Podpr3;
{$APPTYPE CONSOLE} {$O-,Q+,R+}
uses SysUtils;
type
TArr=array[1..10]of Integer;
function wypelniacz(x :Integer):TArr;
var
i: Integer;
begin
for i := 1 to 10 do
Result[i] := x;
end;
Var A :TArr;
i:byte;
begin
A := wypelniacz(2);
for i:=1 to 10 do write(A[i], ' ');
readln;
end.
program CardStr1;
Przykład- funkcja
{$APPTYPE CONSOLE} {$O-,Q+,R+}
ZAMIANY liczby
uses SysUtils;
całkowitej na kod 2-10
const MaxPodst = 10;
type TPodst=2..MaxPodst;
function Card2Str(x :Cardinal; p:TPodst):string;
var
type
a :Cardinal;
TCyfra = 0..MaxPodst-1;
b :TPodst;
var
begin
cyfra :TCyfra;
write('a=');readln(a);
begin
write('podstawa systemu ');
readln(b);
Result := '';
repeat
writeln(Card2Str(a, b));
cyfra := x mod p;
readln;
x := x div p;
end.
Result := char(cyfra+byte('0')) + Result;
until x = 0;
end;
Przykład- funkcja ZAMIANY
program CardStr3efUbocz;
 efekty uboczne
{$APPTYPE CONSOLE} {$O-,Q+,R+}
var
uses SysUtils;
cyfra :TCyfra;
const MaxPodst = 36;
begin
type TPodst=2..MaxPodst;
Result := '';
repeat
var
cyfra := x mod p;
x :Cardinal; p :TPodst;
x := x div p;
function Card2Str:string;
Result := CyfraZnak(cyfra)
type
+ Result;
TCyfra = 0..MaxPodst-1;
until x = 0;
end;
begin
function CyfraZnak(c :TCyfra):char;
write('x=');readln(x);
begin
write('podstawa systemu
if c <= 9 then
liczenia:');readln(p);
Result := char( c + byte('0') )
writeln(Card2Str);
writeln(Card2Str);
else
readln;
Result := char( c-10 +byte('A') );
end.
end;
if N > 1 then
program Sortowanie;
begin
{$APPTYPE CONSOLE} {$O-
i := 2;
,Q+,R+}
repeat
uses SysUtils;
while A[i] < A[i-1] do
const MaxN=5;
begin
var
x := A[i];
N,x :Integer;
A[i] := A[i-1];
A :array[1..MaxN] of
A[i-1] := x;
Integer;
if i > 2 then
i :1..MaxN+1;
i := i-1;
begin
end;
//Read(N, A[1],..., A[N]);
i := i+1;
write('N=');readln(N);
until i > N;
//czytanie rom. tab
end;
for i := 1 to N do
writeln('posortowane');
begin
for i := 1 to N do
write('A[',i,']=');
Writeln('A[',i,']=',A[i]);
readln(A[i]);
readln;
end;
end.
Wywołanie funkcji przez inną funkcję
W czasie wykonywania funkcji może nastąpić
wywołanie innej funkcji.
Wykonywanie bieżącej funkcji jest wówczas chwilowo
przerywane, a rozpoczyna się wykonywanie drugiej.
Po zakończeniu wykonania funkcji drugiej sterowanie
wraca do pierwszej funkcji, do miejsca gdzie została
przerwana.
W treści programu w funkcji można
umieścić wywołanie innej funkcji, która
została zdefiniowana wcześniej
Wywołanie funkcji przez inną funkcję
Zagnieżdżanie 
Zagnieżdżanie  funkcja
Zagnieżdżanie 
podprogram
wywołujący inną
funkcja wywołujący
wywołujący inny
funkcję
inną funkcję
podprogram
function A;
function A;
procedure A;
begin
begin
Function B;
...
...
end;
end;
begin
...
Function B;
procedure B;
end;
begin
begin
...
begin
...
x:=A;
...
... A;
x:=B;
end;
end;
...
end;
Przykład- fukcjA ZAMIANY
program CardStr2;
liczby całkowitej na Hex
{$APPTYPE CONSOLE} {$O-,Q+,R+}
Var cyfra :TCyfra;
uses SysUtils;
begin
Const MaxPodst = 36;
Result := '';
type
repeat
cyfra := x mod p;
TPodst=2..MaxPodst;
x := x div p;
function
Result := CyfraZnak(cyfra)
Card2Str(x :Cardinal; p:TPodst):string;
+ Result;
type
until x = 0;
TCyfra = 0..MaxPodst-1;
end;
var a :Cardinal; b :TPodst;
function CyfraZnak(c :TCyfra):char;
begin
begin
write('a=');readln(a);
if c <= 9 then
write('podstawa systemu:=');
Result := char( c + byte('0') )
readln(b);
writeln(Card2Str(a, b));
else
readln;
Result := char( c-10 +byte('A') );
end.
end;
Zmienne globalne i lokalne
Możemy zdefiniować pewne zmienne, które
będą widoczne we wszystkich funkcjach
danego programu  są to tzw zmienne
globalne
Wewnątrz funkcji można definiować zmienne,
które są zmiennymi lokalnymi tej funkcji
Jeśli w obrębie funkcji definiujemy jakieś zmienne,
to są one zazwyczaj pamiętane na tzw. stosie
(czyli w obszarze  podręcznym ).
Przykład- funkcja ZAMIANY
program CardStr3efUbocz;
 efekty uboczne
{$APPTYPE CONSOLE} {$O-,Q+,R+}
var
uses SysUtils;
cyfra :TCyfra;
const MaxPodst = 36;
begin
type TPodst=2..MaxPodst;
Result := '';
repeat
var
cyfra := x mod p;
x :Cardinal; p :TPodst;
x := x div p;
function Card2Str:string;
Result := CyfraZnak(cyfra)
type
+ Result;
TCyfra = 0..MaxPodst-1;
until x = 0;
end;
begin
function CyfraZnak(c :TCyfra):char;
write('x=');readln(x);
begin
write('podstawa systemu
if c <= 9 then
liczenia:');readln(p);
Result := char( c + byte('0') )
writeln(Card2Str);
writeln(Card2Str);
else
readln;
Result := char( c-10 +byte('A') );
end.
end;
Podsumowanie
jeśli podprogram ma zwracać więcej niż jedną wartość, bądz

modyfikować wartości parametrów aktualnych użyj procedury;
jeśli ma być zwrócona dokładnie jedna wartość użyj funkcji;
jeśli oba typy podprogramów są dopuszczalne użyj tego, który jest ci
łatwiej zastosować
zmienne mające w podprogramie charakter roboczy należy
deklarować jako zmienne lokalne; bardziej bezpieczne zalecane jest
przekazywanie parametrów przez wartość (chroni przed
niepotrzebnymi zmianami tych parametrów)
jeśli parametr służy do komunikowania otoczeniu efektów wykonania
podprogramu to musi być przekazywany przez zmienną;
jeśli mamy do przekazania duże struktury danych to unikamy ich
przekazywania przez wartość  pozwoli to na lepsze
gospodarowanie pamięcią (dla parametrów przekazywanych przez
wartość tworzona jest ich kopia na stosie);