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 *)... (* treść procedury *) 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; n, wynik : LONGINT; CIrScr; Writeln (' Obliczenie sześcianu liczby naturalnej n '); Write (' Podaj liczbę naturalna n, n= '); Readln (n); wynik:=n*n*n;
Write (' Dla n = ',n, ' wynik = ',wynik:10); Writeln ('JeszcAaz?(T)ak'); TakNie: =UpCase(ReadKey) UNTIL NOT (Tak_Nie='T') 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. Cały program został przedstawiony poniżej: PROGRAM Procedura_szescian_1; n, wynik : LONGINT; (* deklaracja zmiennych globalnych*) (*****************************************************) PROCEDURE Sześcian; Writeln (' Obliczenie sześcianu liczby naturalnej n '); Write ('Podaj liczbę naturalna n, n = '); Readln (n); wynik:=n*n*n; Write (' Dla n = ',n,' wynik = ',wynik); (* program główny *) Sześcian; (* wywołanie procedury *) Writeln ('Jeszcze raz?(t)ak'); Tak_Nie:=UpCase(ReadKey) UNTIL NOT (Tak Nie='T')
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; Tak_Nie:CHAR; (****************************) PROCEDURE Sześcian; n, wynik : LONGINT; (* Zmienne lokalne *) Writeln (' Obliczenie sześcianu liczby naturalnej n '); Write (' Podaj liczbę naturalna n, n = '); Readln (n); wynik:=n*n*n; Write (' Dla n = ',n,' wynik = ',wynik); (*************) Sześcian; Writeln ('Jeszcze raz?(t)ak'); Tak_Nie:=UpCase(ReadKey) UNTIL NOT (Tak Nie='T') 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. 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. Cały program został przedstawiony poniżej: PROGRAM Procedura_szescian_3; n, wynik : LONGIN; (**************************) PROCEDURE Szescia( a:longint); (* przekazywanie parametrów do procedury przez wartość *) wynik:=a*a*a; Write (' Dla n = ',a,' wynik = ',wynik); (**********************************) (* program glowny *) Writeln (' Obliczanie sześcianu liczby naturalnej n '); Write (' Podaj liczbę naturalna n = '); Readln (n); Szescian(n); Writeln (' Jeszcze raz?(t)ak'); Tak Nie:=UpCase(ReadKey) UNTIL NOT (Tak_Nie='T') 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; 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. 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; PROGRAM Procedura_szescian_4; n, wynik : LONGINT; (********************************) PROCEDURE Sześcian (a:longint; iloczyn:longint); (* przekazywanie parametrów przez zmienne*) iloczyn:=a*a*a; Write (' Dla n = ',a,' wynik = ',iloczyn); (*****************************) Writeln (' Obliczenie sześcianu liczby naturalnej n '); Write (' Podaj liczbę naturalna n = '); Readln (n); Szescian(n,wynik); Writeln ('Jeszcze raz?(t)ak'); Tak_Nie:=UpCase(ReadKey) UNTIL NOT (Tak Nie='T') Ć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 ax 2 +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. 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. 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. 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. 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 *)..... (* treść funkcji *)
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. Cały program został przedstawiony poniżej: PROGRAM Funkcja_mniejsza; a, b, min, mniej : LONGINT; (************************************) FUNCTION Mniejsza:LONGINT; Writeln (' Wyznaczenie liczby mniejszej '); Writeln (' Podaj dwie niezerowe rożne liczby naturalne:');
Write (' Podaj liczbę naturalna a= '); Readln (a); Write (' Podaj liczbę naturalna b= '); Readln (b); UNTIL a<>b; IF a>b THEN min:=b Else min:=a; Mniejsza:=min; (* nadanie funkcji wartości min *) (****************************************) mniej:=mniejsza; (* przypisanie wyniku funkcji zmiennej *) Writeln('Z liczb ',a,' i ',b,' liczba mniejsza to ',mniej); Writeln (' Jeszcze raz?(t)ak'); TakNie: =UpCase(ReadKey) UNTIL NOT (Tak Nie='T') 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. Cały program został przedstawiony poniżej: Program Potegi_liczby_2; wynik : LONGINT; (***********************************) FUNCTION Potęga_dwa : LONGINT; (* Obliczanie wyrażenia 2 do potęgi n*)
n, X : LONGINT; WHILE n>30 DO Write (' Podaj wykładnik potęgi ( n<=30), n= '); Readln(n); X:=1; Write(' 2 do potęgi ',n); FOR n:=1 to n DO X:=X*2 (* rekurencja *) Potega_dwa:=X; (***********************************) WritelnC Obliczenie wyrażenia: 2 do potęgi n '); wynik:=potega_dwa; Write(' = ',wynik); Writeln (' Jeszcze raz?(t)ak'); TakNie: =UpCase(ReadKey) UNTIL NOT (Tak Nie='T') 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): 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1. 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. 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; a : BYTE; (*********************************) FUNCTION Silnia (n:byte): LONGINT; IF n=0 THEN Silnia:=l; IF n>0 THEN Silnia:=n*Silnia (n-1); (********************************) Writeln (' Obliczenie wyrażenia a! (a silnia) 1 ); Write (' Podaj liczbę naturalna z zakresu: 1-10 : a= '); Readln (a); Write (' ', a,'! = ',Silnia(a)); Writeln (' Jeszcze raz?(t)ak'); Tak Nie:=UpCase(ReadKey) UNTIL NOT (Tak Nie='T') 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 = x 3 + 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 = x 3 + 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( 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 ). 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; Cały program został przedstawiony poniżej: PROGRAM Funkcja_szescian_4; x, y : LONGINT; z : LONGINT; TakNie : CHAR; (********************************) FUNCTION Szescian( a, b:longint): LONGINT; a:=a*a*a; b:=b*b*b; Sześcian :=a+b; (*********************************) Writeln('Obliczenie sumy sześcianów dwóch liczb całkowitych'); Write (' Podaj liczbę naturalna x= '); Readln (x); Write (' Podaj liczbę naturalna y= '); Readln (y); 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 (* Jeszcze raz?(t)ak'); Tak_Nie:=UpCase (ReadKey) UNTIL NOT (Tak_Nie='T')
Ć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. Do wyznaczenia pierwiastka kwadratowego z zadanej liczby a zastosujemy algorytm Herona. W pierwszym kroku przybliżymy wartość a liczbą b. Przyjmujemy b 1, =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 b 1 i a/b,. Kolejne przybliżenie pierwiastka to średnia arytmetyczna obu krańców przedziału b 2 =( b 1 + a/b 1 )/2. Kolejne przybliżenia mają postać b n+1 = ( b n + a / b n ) / 2. Dokładność obliczenia eps=1e-6 jest różnicą między wartościami b n i a/b n.