Podprogramy Procedury

Transkrypt

Podprogramy
Turbo Pascal oferuje metody ułatwiające tworzenie struktury programu, szczególnie dotyczy to większych programów. Przy
tworzeniu większego programu stosuje się jego podział na kilka mniejszych programów zwanych podprogramami. Komunikacja
pomiędzy podprogramami a pozostałą częścią programu odbywa się w ściśle określony sposób.
Do tego celu wykorzystywane są zmienne bądź stałe globalne, zadeklarowane w programie głównym lub parametry, w
definicji podprogramu nazywane parametrami formalnymi, a przy wywoływaniu podprogramu parametrami aktualnymi.
Wybór sposobu przekazywania danych procedurze zależy od konkretnej sytuacji. Bardzo często stosowane są jednocześnie
obie metody.
Podprogram może być wielokrotnie wywoływany z głównej części programu lub z innych podprogramów. Podprogramy mogą
zarówno wczytywać dane, jak i wyprowadzać wyniki. W treści programu muszą być one umieszczone przed częścią główną
programu. Musi zostać zachowana określona kolejność deklaracyjna.
W Turbo Pascalu występują dwa rodzaje podprogramów: procedury i funkcje.
Procedury
Ogólna postać procedury jest następująca:
Procedure nazwa (lista parametrów formalnych);
.............
............. (* deklaracja stałych, zmiennych i typów *)
BEGIN
............. (* treść procedury *)
END;
Po nazwie procedury lista parametrów formalnych może wystąpić lub nie.
Wywołanie procedury polega na podaniu nazwy procedury wraz z listą parametrów aktualnych (o ile takie istnieją).
Dla lepszego zrozumienia istoty procedury wykonamy najpierw następne ćwiczenie.
Ćwiczenie 56
Napisać program obliczający sześcian dowolnej liczby naturalnej. Program ma tytuł „Szescian_n_1". Zapisać program na dysku w
pliku o nazwie nszesc_1.pas.
Dla przejrzystości programu świadomie zrezygnowano z wielokrotnego powtarzania sekwencji, które uzasadniałyby od razu
potrzebę zastosowania procedur.
Cały program został przedstawiony poniżej:
PROGRAM Sześcian_n_1;
USES
Crt;
VAR
n, wynik : LONGINT;
Tak Nie : CHAR;
BEGIN
REPEAT
CIrScr;
Writeln (' Obliczenie sześcianu liczby naturalnej n ');
Writeln;
Write (' Podaj liczbę naturalna n, n= ');
Readln (n);
wynik:=n*n*n;
Writeln;
Write (' Dla n = ',n, ' wynik = ',wynik:10);
Writeln;
Writeln ('JeszcAaz ?(T)ak');
TakNie: =UpCase(ReadKey)
UNTIL NOT (Tak_Nie='T')
END.
Program ,,Sześcian_n_1 zawierał tylko jeden blok strukturalny. Był to blok programu głównego. Blok ten nazywamy
blokiem zewnętrznym.
Zmienne zadeklarowane w bloku programu głównego (blok zewnętrzny) noszą nazwę zmiennych globalnych.
W programie głównym mogą wystąpić odpowiednio zdefiniowane bloki (np. procedury, funkcje), które są blokami
wewnętrznymi. Podobnie w przypadku dwóch bloków, z których jeden zawiera drugi, mamy do czynienia z blokiem zewnętrznym
i blokiem wewnętrznym.
Zmienne zadeklarowane w danym bloku strukturalnym zachowują swoją ważność nie tylko w nim (lokalnie), ale również we
wszystkich blokach wewnętrznych (globalnie).
W następnym ćwiczeniu blok instrukcji związany z obliczeniem sześcianu dowolnej liczby naturalnej zostanie przedstawiony
w postaci procedury (podprogramu) wykorzystującej zmienne globalne do przekazania parametrów.
Ćwiczenie 57
Napisać program zawierający procedurę obliczania sześcianu dowolnej liczby naturalnej. Procedura ma wykorzystywać zmienne
globalne. Program ma tytuł „Procedura_szescian_1". Zapisać program na dysku w pliku o nazwie proced_1.pas.
Program zawiera dwa bloki strukturalne: program główny (blok zewnętrzny) oraz procedurę (blok wewnętrzny).
Po słowie kluczowym PROCEDURE i po nazwie procedury (Sześcian) nie występuje lista parametrów formalnych. Zmienna n oraz
wynik (zadeklarowane w programie głównym) są zmiennymi globalnymi dla procedury Sześcian, czyli dostępne dla tej
procedury. Mamy tutaj do czynienia z przekazywaniem danych przez zmienne globalne.
PROGRAM Procedura_szescian_1;
USES
Crt;
VAR
n, wynik : LONGINT; (* deklaracja zmiennych globalnych*)
Tak Nie : CHAR;
(*****************************************************)
PROCEDURE Sześcian;
BEGIN
Writeln;
Writeln;
Write ('Podaj liczbę naturalna n, n = ');
Readln (n);
wynik:=n*n*n;
Writeln;
Write (' Dla n = ',n,' wynik = ',wynik);
Writeln;
END;
BEGIN
(* program główny *)
REPEAT ClrScr;
Sześcian;
(* wywołanie procedury *)
Writeln ('Jeszcze raz ?(T)ak');
Tak_Nie:=UpCase(ReadKey)
UNTIL NOT (Tak Nie='T')
END.
W poprzednim programie wykorzystaliśmy w procedurze zmienne globalne zadeklarowane w bloku programu głównego.
Podobnie jak program, procedura może posiadać swoje własne struktury (zmienne, stałe, typy, procedury, funkcje). Deklaruje się je
tak jak w programie.
Zasięg nazw deklarowanych w obrębie danych procedur rozciąga się tylko na obszary procedur, w których zostały
zadeklarowane. Zmienne zadeklarowane w procedurze (blok wewnętrzny) noszą nazwę zmiennych lokalnych.
W następnym ćwiczeniu przedstawiono program zawierający procedurę z własnym blokiem deklaracyjnym (zmienne lokalne).
Ćwiczenie 58
Napisać program zawierający procedurę obliczania sześcianu dowolnej liczby naturalnej. Procedura ma zawierać blok
deklaracyjny (własną strukturą). Program ma tytuł „Procedura_szescian_2". Zapisać program na dysku w pliku o nazwie
prod_2.pas.
Program zawiera dwa bloki strukturalne: program główny (blok zewnętrzny) oraz procedurę (blok wewnętrzny).
Po słowie kluczowym PROCEDURE i po nazwie procedury (Sześcian) nie występuje lista parametrów formalnych. Zmienna n oraz
wynik, zadeklarowane w procedurze, są zmiennymi lokalnymi dla procedury Sześcian, czyli dostępne tylko dla tej procedury.
Mamy tutaj do czynienia z przekazywaniem danych przez zmienne lokalne.
Cały program został przedstawiony poniżej :
PROGRAM Procedura_szescian_ 2;
USES
Crt;
VAR
Tak_Nie:CHAR;
(****************************)
PROCEDURE Sześcian;
VAR
n, wynik : LONGINT;
(* Zmienne lokalne *)
BEGIN Writeln;
Writeln;
Write (' Podaj liczbę naturalna n, n = ');
Readln (n);
wynik:=n*n*n;
Writeln;
Write (' Dla n = ',n,' wynik = ',wynik);
Writeln;
END;
(*************)
BEGIN
REPEAT
ClrScr;
Sześcian;
END.
Korzystanie ze zmiennych (stałych itp.) globalnych ogranicza w znacznej mierze rozbudowę poszczególnych części programu
(konieczność analizy obcej procedury ze względu np. na typ użytych tam zmiennych globalnych).
Bardziej uniwersalnym i częściej stosowanym rozwiązaniem jest koncepcja bezpośredniego przekazywania danych
procedurom, tj. z wykorzystaniem parametrów formalnych. Parametry te mogą być przekazywane przez wartość lub zmienne.
Parametry przekazywane przez wartość służą jedynie do wprowadzania wartości danych do wnętrza procedury.
Parametry te są dostępne tylko dla danej procedury i jej wszystkich ewentualnych bloków wewnętrznych, lecz nie są dostępne
dla bloku zewnętrznego, a więc nie można za ich pomocą wyprowadzać wyników z procedury.
W następnym ćwiczeniu zajmiemy się programem zawierającym procedurę wykorzystującą parametry formalne przekazywane
przez wartość do komunikacji pomiędzy podprogramem a pozostałą częścią programu.
Ćwiczenie 59
Napisać program zawierający procedurę obliczającą sześcian dowolnej liczby naturalnej. Procedura zawiera deklaracje
odpowiednich parametrów formalnych przekazywanych przez wartość. Program ma tytuł „Procedura_szescian_3". Zapisać
program na dysku w pliku o nazwie proced_3.pas.
W programie zastosujemy procedurę zawierającą deklaracje odpowiednich parametrów formalnych przekazywanych przez
wartość. Po słowie kluczowym PROCEDURE i po nazwie procedury (Sześcian) zadeklarowany został parametr a. Jest to
parametr formalny przekazywany przez wartość.
Wywołując procedurę należy podać dokładnie tyle parametrów, ile zadeklarowano.
Przy wywołaniu procedury wartość aktualnego parametru n zostaje przekazana procedurze Sześcian:
Szescian(n);
Formalny parametr a służy tu tylko do rezerwacji miejsca przeznaczonego do wpisania wartości przesyłanej przez parametr
aktualny.
Wyniki przeprowadzanych w procedurze operacji na parametrach przekazywanych przez wartość są dostępne tylko dla danej
procedury i jej wszystkich ewentualnych bloków wewnętrznych, lecz nie są dostępne dla bloku zewnętrznego.
Uwaga:
Parametry formalne użyte w danej procedurze mogą być definiowane w dowolnej kolejności. Przy wywoływaniu takiej procedury w
programie należy uważać, by przekazywane jej wartości parametrów aktualnych odpowiadały kolejności deklaracyjnej
parametrów formalnych.
USES
Crt;
VAR
n, wynik : LONGIN;
Tak Nie : CHAR;
(**************************)
PROCEDURE Szescia( a:LONGINT);
(* przekazywanie parametrów do procedury przez wartość *)
BEGIN
Writeln;
wynik:=a*a*a;
Write (' Dla n = ',a,' wynik = ',wynik);
Writeln;
END;
(**********************************)
BEGIN
REPEAT
(* program glowny *)
ClrScr;
Writeln (' Obliczanie sześcianu liczby naturalnej n ');
Writeln;
Write (' Podaj liczbę naturalna n = ');
Readln (n);
Szescian(n);
Writeln (' Jeszcze raz ?(T)ak');
Tak Nie:=UpCase(ReadKey)
END.
W następnym ćwiczeniu zajmiemy się procedurą wykorzystującą parametry formalne przekazywane przez zmienną. Ten
sposób przekazywania parametrów umożliwia przesyłanie przez procedurę do programu wywołującego więcej niż jedną wartość.
Parametry przekazywane przez zmienne mogą służyć do wprowadzania wartości danych do wnętrza procedury, ale główne ich
zadanie polega na przekazywaniu wyników działania procedury na zewnątrz.
Ćwiczenie 60
Napisać program zawierający procedurę obliczającą sześcian dowolnej liczby naturalnej. Procedura zawiera deklaracje
odpowiednich parametrów formalnych przekazywanych przez zmienne. Program ma tytuł „Procedura_szescian_4". Zapisać
program na dysku w pliku o nazwie proced_4.pas.
Po słowie kluczowym PROCEDURE i po nazwie procedury (Sześcian) zadeklarowane zostały zmienne: a i iloczyn:
PROCEDURE Sześcian ( a:LONGINT; VAR iloczyn :LONGINT);
Parametr formalny a występujący w procedurze służy jedynie do przekazania wartości aktualnego parametru n do procedury. Jest to
przekazywane parametru przez wartość.
Parametr iloczyn, występujący w procedurze, został poprzedzony w nagłówku słowem kluczowym VAR.
Oznacza to, że jest on parametrem przekazywanym przez zmienną i służy do wyprowadzenia wyniku obliczeń do bloku
zewnętrznego programu głównego). W tym przypadku parametry aktualne muszą być nazwami zmiennych odpowiedniego typu.
Cały program został przedstawiony poniżej;
USES
Crt;
VAR
n, wynik : LONGINT;
Tak Nie : CHAR;
(********************************)
PROCEDURE Sześcian (a:LONGINT; VAR iloczyn:LONGINT);
BEGIN
(* przekazywanie parametrów przez zmienne*)
Writeln;
iloczyn:=a*a*a;
Write (' Dla n = ',a,'
Writeln;
END;
wynik = ',iloczyn);
(*****************************)
BEGIN
REPEAT
ClrScr;
Writeln;
Writeln;
Write (' Podaj liczbę naturalna n = ');
Readln (n);
Szescian(n,wynik);
END.
Ćwiczenie 61
Uruchomić program Turbo Pascal. Napisać program zawierający procedurę rozwiązania układu trzech równań liniowych z trzema
niewiadomymi x, y, z:
ax + by + cz = m,
dx + ey + fz = n,
gx + ky + lz = p.
Procedura wykorzystuje zmienne globalne. Program ma tytuł „ Układ_liniowy". Zapisać program na dysku w pliku o nazwie
uklad_1.pas. Wykonać obliczenia dla następujących danych: a-1, b=1, c=1, m=4, d=3, e= -1, f=6, n=14, g=4, k=5, l=-7, p=-5.
Ćwiczenie 62
Napisać program zawierający procedurę obliczającą sumę składników następującego szeregu:
1+22+333+4444+55555+...
Procedura zawiera deklaracje odpowiednich parametrów formalnych przekazywanych przez wartość i zmienne. Program ma tytuł
„Szereg_1". Zapisać program na dysku w pliku o nazwie szereg_1.pas. Wykonać obliczenia sumy dla 7 składników tego szeregu.
Ćwiczenie 63
Napisać program zawierający procedurę obliczającą pierwiastki równania kwadratowego ax2 +bx + c = 0. Procedura zawiera
deklaracje odpowiednich parametrów formalnych przekazywanych przez wartość i zmienne. Program ma tytuł
„Równanie_kwadratowe". Zapisać program na dysku w pliku o nazwie rkwad_1.pas.
Uwaga:
W programie przyjąć za wartość zerową (do sprawdzenia delty) liczbę bardzo małą np. 1e-6.
Ćwiczenie 64
Napisać program zawierający procedurę obliczania ułamka zwykłego, którego rozwinięcie dziesiętne jest ułamkiem w postaci
0,(abc) (np. 0,(123)). Program ma tytuł „Ulamek_zwykly". Zapisać program na dysku w pliku o nazwie uzwyk_1.pas.
•
Ćwiczenie 65
Napisać program zawierający procedurę uzyskiwania „lustrzanego odbicia" danej liczby naturalnej. Program ma tytuł
„Odbicie_lustrzane". Zapisać program na dysku w pliku o nazwie lustro_1.pas. Wykonać obliczenia dla 31245.
Uwaga:
Patrz ćwiczenie 53 (plik scdn_1.pas).
Ćwiczenie 66
Napisać program zawierający procedurę wyznaczania największego wspólnego podzielnika dowolnej liczby liczb naturalnych
(NWD). Program ma tytuł „Procedura_NWD_1". Zapisać program na dysku w pliku o nazwie pnwd_1.pas.
Uwaga:
Patrz ćwiczenie 51 (plik nwd_1.pas).
Ćwiczenie 67
Napisać program zawierający procedurę wyznaczania najmniejszej wspólnej wielokrotności dowolnej liczby liczb naturalnych
(NWW). Program ma tytuł „Procedura_NWW_1". Zapisać program na dysku w pliku o nazwie pnww_1.pas.
Uwaga:
Patrz ćwiczenie 52 (plik nww_1.pas).
Funkcje
Ogólna postać funkcji jest następująca:
Function nazwa_funkcji (lista parametrów formalnych ): typ wyniku;
………..
............ (* deklaracja stałych, zmiennych i typów *)
………..
BEGIN
............ (* treść funkcji *)
END;
Po słowie kluczowym Function i po nazwie funkcji występuje lista parametrów formalnych zawierająca nazwy
parametrów i nazwy ich typów.
W treści funkcji musi być umieszczone przypisanie:
nazwa_funkcji := wynik;
Przypisanie to nadaje nazwie_funkcji zmienną lub stałą określającą przekazywaną wartość. W odróżnieniu od procedury w
nagłówku funkcji musi wystąpić typ wyniku.
Wywołanie funkcji polega na przypisaniu pewnej zmiennej nazwy funkcji wraz z listą parametrów aktualnych:
zmienna : = nazwa_funkcji (lista parametrów formalnych);
lub też umieszczeniu nazwy funkcji w określonym wyrażeniu.
Umożliwia to przekazanie wartości funkcji w miejsce wywołania tej funkcji.
Z powyższego zapisu wynika, że funkcja pełni rolę zmiennej.
W gruncie rzeczy procedury i funkcje są bardzo do siebie podobne. Jedne i drugie posługiwać się mogą parametrami
formalnymi. Jednak w przeciwieństwie do procedur, funkcje mają zawsze określony rezultat o typie określonym przez typ
wyniku funkcji.
W następnym ćwiczeniu blok instrukcji, związany z obliczeniem sześcianu dowolnej liczby naturalnej, zostanie przedstawiony
w postaci funkcji (podprogramu) wykorzystującej zmienne globalne do przekazywania parametrów. Jak pamiętamy, zmienne
zadeklarowane w bloku programu głównego (blok zewnętrzny) noszą właśnie nazwę zmiennych globalnych.
Ćwiczenie 68
Napisać program zawierający funkcję wyznaczania mniejszej liczby z dwóch podanych liczb. Funkcja wykorzystuje zmienne
globalne. Program ma tytuł „Funkcja_mniejsza". Zapisać program na dysku w pliku o nazwie f_min_1.pas.
Program zawiera dwa bloki strukturalne: program główny (blok zewnętrzny) oraz funkcję (blok wewnętrzny).
Po słowie kluczowym FUNCTION i po nazwie funkcji (Mniejsza) nie występuje lista parametrów formalnych, lecz jedynie typ
wyniku:
Mniejsza :LONGINT;
Brak parametrów formalnych wynika z faktu korzystania ze zmiennych globalnych przez funkcję. Zmienne a, b, min, mniej
(zadeklarowane w programie głównym) są zmiennymi globalnymi dla funkcji Mniejsza, czyli są dostępne dla tej funkcji. Mamy
tutaj do czynienia z przekazywaniem danych przez zmienne globalne.
Istotnym elementem, jak pamiętamy, w treści każdej funkcji jest instrukcja przypisania nazwie funkcji jej wartości. W treści
naszej funkcji wystąpi więc instrukcja przypisania:
Mniejsza:=min;
Umożliwia to przekazanie wartości funkcji w miejsce wywołania tej funkcji.
PROGRAM Funkcja_mniejsza;
USES
Crt;
VAR
a, b, min, mniej : LONGINT;
Tak Nie
: CHAR;
(************************************)
FUNCTION Mniejsza:LONGINT;
BEGIN
REPEAT
ClrScr;
Writeln (' Wyznaczenie liczby mniejszej ');
Writeln (' Podaj dwie niezerowe rożne liczby naturalne:');
Writeln;
Write (' Podaj liczbę naturalna a= ');
Readln (a);
Write (' Podaj liczbę naturalna b= ');
Readln (b);
Writeln;
UNTIL a<>b;
IF a>b THEN min:=b
Else min:=a;
Mniejsza:=min; (* nadanie funkcji wartości min *)
END;
(****************************************)
BEGIN
REPEAT
ClrScr;
Writeln;
mniej:=Mniejsza; (* przypisanie wyniku funkcji zmiennej *)
Writeln('Z liczb ',a ,' i ',b ,' liczba mniejsza to ',mniej);
Writeln;
END.
W poprzednim programie wykorzystaliśmy w funkcji zmienne globalne zadeklarowane w bloku programu głównego.
Podobnie jak program czy też procedura, funkcja może posiadać swoje własne struktury (zmienne, stałe, typy, procedury, funkcje).
Deklaruje się je tak jak w programie.
Zasięg nazw deklarowanych w obrębie danych funkcji rozciąga się tylko na obszary funkcji, w których zostały
zadeklarowane i na bloki wewnętrzne tych funkcji (o ile one istnieją). Zmienne zadeklarowane w funkcji (blok wewnętrzny) noszą
nazwę zmiennych lokalnych.
W następnym ćwiczeniu przedstawiono program zawierający funkcję z własnym blokiem deklaracyjnym (zmienne lokalne).
Ćwiczenie 69
Napisać program zawierający funkcję wyznaczania wartości n-tej potęgi liczby 2 . Funkcja zawiera zmienne lokalne. Program ma
tytuł „Funkcja_potegi_liczby_2". Zapisać program na dysku w pliku o nazwie pot_2.pas.
Program zawiera dwa bloki strukturalne: program główny (blok zewnętrzny) oraz funkcję (blok wewnętrzny).
Po słowie kluczowym FUNCTION i po nazwie funkcji nie występuje lista parametrów formalnych, lecz jedynie typ wyniku:
Potęga_dwa: LONGINT;
Zmienna n oraz X, zadeklarowane w funkcji, są zmiennymi lokalnymi tej funkcji. Mamy tutaj do czynienia z przekazywaniem
danych przez zmienne lokalne. W treści funkcji wystąpi instrukcja przypisania nazwie funkcji jej wartości:
Potęga_dwa:=X;
Umożliwia to, jak wiemy, przekazanie wartości funkcji w miejsce wywołania tej funkcji. W celu obliczenia danej potęgi liczby 2
wykorzystano wzór rekurencyjny X:=X*2. Każda następna wartość X jest dwukrotnie większa od poprzedniej.
Program Potegi_liczby_2;
USES
Crt;
VAR
wynik : LONGINT;
Tak Nie : CHAR;
(***********************************)
FUNCTION Potęga_dwa : LONGINT;
(* Obliczanie wyrażenia 2 do potęgi n*)
VAR n, X : LONGINT;
BEGIN
WHILE n>30 DO
BEGIN
Write (' Podaj wykładnik potęgi ( n<=30), n= ');
Readln(n);
END;
X:=1;
Writeln;
Write(' 2 do potęgi ',n);
BEGIN
FOR n:=1 to n DO
X:=X*2
(* rekurencja *)
END;
Potega_dwa:=X;
END;
(***********************************)
BEGIN
REPEAT
ClrScr;
Writeln;
WritelnC Obliczenie wyrażenia: 2 do potęgi n ');
Writeln;
wynik:=Potega_dwa;
Write(' = ',wynik);
Writeln; Writeln;
END.
Bardziej uniwersalnym i najczęściej stosowanym rozwiązaniem, zarówno dla procedur, jak i funkcji, jest koncepcja
bezpośredniego przekazywania danych funkcjom (tj. wykorzystując parametry formalne).
Przekazywanie parametrów w przypadku funkcji odbywa się na dokładnie takich samych zasadach jak w procedurach.
W następnym ćwiczeniu zajmiemy się funkcją przekazującą parametry przez wartość. Jak pamiętamy, parametry
przekazywane przez wartość służą tylko i wyłącznie do przekazywania parametrów aktualnych do wnętrza funkcji.
Ćwiczenie 70
Napisać program z zastosowaniem funkcji wyznaczającej rekurencyjnie silnię z dowolnej liczby naturalnej. Funkcja zawiera
deklaracje odpowiednich parametrów formalnych przekazywanych przez wartość. Program ma tytuł „Silnia_rekurencyjna_1".
Zapisać program na dysku w pliku o nazwie silnia_1.pas.
Symbolem n! oznaczamy iloczyn wszystkich liczb naturalnych od 1 do n. Nazywamy to silnią liczby n. Np. 3! = 1 * 2 * 3 , czyli
3!=6. Silnia jest również liczbą określająca liczbę wszystkich możliwych ustawień n symboli, na przykład liczb od 1 do n. Liczby 1,
2, 3 możemy ustawić na 6 sposobów (3!=6):
123
132
213
231
312
321.
Należy pamiętać, że dla n=0 mamy 0!=1.
W programie na obliczenie n! zastosujemy wzór rekurencyjny:
n! = n*(n-l)!
Po słowie kluczowym FUNCTION i po nazwie funkcji (Silnia) zadeklarowany został parametr n wraz z określeniem jego typu (n :
BYTE). Jest to parametr formalny przekazywany przez wartość. Wartość aktualnego parametru a zostaje przekazana funkcji
Silnia:
Silnia (a) ;
Formalny parametr n posłużył tu, podobnie jak w procedurze, tylko do rezerwacji miejsca przeznaczonego do wpisania wartości
przesyłanej przez parametr aktualny. Wyniki przeprowadzanych w funkcji operacji na parametrach przekazywanych przez
wartość są dostępne tylko dla danej funkcji i jej wszystkich ewentualnych bloków wewnętrznych, nie są jednak dostępne dla bloku
zewnętrznego.
W zastosowanym rozwiązaniu funkcji przyjęto operowanie nazwą funkcji (Silnia), stąd też wyeliminowana została konieczność
zastosowania instrukcji przypisania nazwie funkcji jej wartości.
Uwaga:
Parametry formalne użyte w danej funkcji mogą być definiowane w dowolnej kolejności. Przy wywoływaniu takiej funkcji w
programie należy uważać, by przekazywane jej wartości parametrów aktualnych odpowiadały kolejności deklaracyjnej
parametrów formalnych.
Poniżej został przedstawiony cały program:
PROGRAM Silnia_rekurencyjna_1;
USES
Crt;
VAR
a
: BYTE;
Tak Nie : CHAR;
(*********************************)
FUNCTION Silnia (n:BYTE): LONGINT;
BEGIN
IF n=0 THEN
Silnia:=l;
IF n>0 THEN
Silnia:=n*Silnia (n-1);
END;
(********************************)
BEGIN
REPEAT
ClrScr;
Writeln (' Obliczenie wyrażenia a! (a silnia)1);
Writeln;
Write (' Podaj liczbę naturalna z zakresu: 1 - 10 : a= ');
Readln (a);
Writeln;
Write (' ', a,'! = ',Silnia(a));
Writeln;
Tak Nie:=UpCase(ReadKey)
END.
W następnym ćwiczeniu zajmiemy się funkcją wykorzystującą parametry formalne przekazywane przez zmienną.
Parametry przekazywane przez zmienne, tak jak w przypadku procedur, mogą służyć do wprowadzania wartości danych do
wnętrza funkcji, ale główne ich zadanie polega na przekazywaniu wyników działania funkcji na zewnątrz.
Ćwiczenie 71
Napisać program zawierający funkcję obliczającą sumę sześcianów dwóch liczb naturalnych wg wzoru:
z = x3 + y 3 .
Funkcja zawiera deklaracje odpowiednich parametrów formalnych przekazywanych przez zmienne. Program ma tytuł
„Funkcja_z_szescian_4". Zapisać program na dysku w pliku o nazwie func_4.pas.
Napisać program zawierający funkcję (z parametrami formalnymi przekazywanymi przez zmienne) obliczającą sumę sześcianów
dwóch liczb naturalnych wg wzoru:
z = x3 + y 3 .
W treści funkcji możemy umieścić wyrażenie, w którym obliczony sześcian pierwszej liczby staje się wartością tej liczby, czyli:
a: = a * a * a .
Podobnie w przypadku drugiej liczby:
b:=b*b*b .
Wartość funkcji Sześcian da nam obliczoną wartość wyrażenia a+b, czyli sumę sześcianów dwóch liczb a i b.
Po słowie kluczowym FUNCTION i po nazwie funkcji (Sześcian) zadeklarowane zostały zmienne: a oraz b:
FUNCTION Szescian(VAR a, b :INTEGER) :INTEGER;
Parametry formalne a i b występujące w funkcji służą do przekazania wartości aktualnych parametrów x oraz y do funkcji (zostały
one poprzedzone słowem kluczowym VAR).
Oznacza to, że są one parametrami przekazywanymi przez zmienne, a tym samym dostępnymi dla bloku zewnętrznego. W
programie głównym będą dostępne nowe, obliczone wartości x oraz y. W tym przypadku parametry aktualne muszą być nazwami
zmiennych odpowiedniego typu. W treści funkcji wystąpi instrukcja przypisania nazwie funkcji jej wartości:
Sześcian :=a+b;
PROGRAM Funkcja_szescian_4;
USES
Crt;
VAR
x, y
: LONGINT;
z
: LONGINT;
TakNie : CHAR;
(********************************)
FUNCTION Szescian(VAR a, b:LONGINT): LONGINT;
BEGIN
Writeln;
a:=a*a*a;
b:=b*b*b;
Sześcian :=a+b;
END;
(*********************************)
BEGIN
REPEAT
ClrScr;
Writeln('Obliczenie sumy sześcianów dwóch liczb całkowitych');
Writeln;
Write (' Podaj liczbę naturalna x= ');
Readln (x);
Write (' Podaj liczbę naturalna y= ');
Readln (y);
Writeln;
Writeln('Obliczenie sumy sześcianów dwóch liczb: x= ',x,' ','i y= ',y);
z:=Szescian(x,y);
Writeln (' Wartość wyrażenia x*x*x = ',x);
Writeln (' Wartość wyrażenia y*y*y = ',y);
Writeln (' Wartość wyrażenia x*x*x + y*y*y = ',z);
Writeln;
Writeln (* Jeszcze raz ?(T)ak');
Tak_Nie:=UpCase (ReadKey)
END.
Ćwiczenie 72
Napisać program zawierający funkcję obliczającą sumę wszystkich podzielników dowolnej liczby naturalnej. W programie
wykorzystać parametry formalne do przekazywania danych do funkcji. Program ma tytuł „Funkcja_czynniki_1". Zapisać program
na dysku w pliku o nazwie f_czyn_1.pas.
Ćwiczenie 73
Napisać program zawierający funkcję obliczającą iloraz dwóch liczb rzeczywistych. Program ma wykorzystywać zmienne lokalne
do przekazywania danych do funkcji. Program ma tytuł „Funkcja_iloraz_2". Zapisać program na dysku w pliku o nazwie
funilo_2.pas.
Ćwiczenie 74
Napisać program zawierający funkcję obliczania przybliżonej wartości sumy nieskończonego szeregu postaci:
Funkcja ma wykorzystywać parametry formalne do przekazywania danych. Obliczenia zostają zakończone w momencie, gdy
wartość kolejnego wyrazu szeregu będzie mniejsza od zadanej dokładności eps=1e-6. Program ma tytuł „Funkcja_Suma_ szeregu"
. Zapisać program na dysku w pliku o nazwie f_szereg.pas.
Ćwiczenie 75
Napisać program zawierający funkcję obliczania przybliżonej wartości pierwiastka kwadratowego z liczby rzeczywistej a (a>0).
Dokładność obliczenia eps=le-6. Funkcja ma wykorzystywać parametry formalne do przekazywania danych. Program ma tytuł
„Funkcja JPierwiastek". Zapisać program na dysku w pliku o nazwie f_pierw.pas.
Uwaga:
Do wyznaczenia pierwiastka kwadratowego z zadanej liczby a zastosujemy algorytm Herona. W pierwszym kroku przybliżymy
wartość
a liczbą b. Przyjmujemy b1, =a. Jeśli b,<
a , to a/b> a i odwrotnie: jeśli b1> a , to a/b< a . Wynika stąd, że
dokładna wartość pierwiastka leży między wartościami b1 i a/b,. Kolejne przybliżenie pierwiastka to średnia arytmetyczna obu
krańców przedziału b2=( b1+ a/b1)/2. Kolejne przybliżenia mają postać bn+1= ( b n + a / b n ) / 2 . Dokładność obliczenia eps=1e-6
jest różnicą między wartościami bn i a/bn.

Podprogramy Procedury

Transkrypt

Podobne dokumenty

Pierwszy program w Pascalu Kod programu

Program obsługujący pliki elementowe

Wprowadzenie komentarzy do programu Instrukcja wyboru CASE

L7. Wprowadzanie danych.

1/4 Ćwiczenie 1. Ułóż program, który wczyta i wyświetli pierwszy

L11. Pętla repeat .. until.

Hasło pas