VI.

Procedury i funkcje – metody

Język Visual Basic 2010 umożliwia programiście utworzenie ciągu instrukcji i nadanie mu na-

zwy. Możliwość ta jest odzwierciedleniem praktyki życiowej polegającej na nadawaniu pewnemu cią-

gowi czynności nazwy, która jednoznacznie opisuje te czynności oraz ich kolejność. Przykładami ta-

kich nazw są: odkurzanie, skakanie ze spadochronem, smażenie jajecznicy itp. Drugi przykład ma tu

szczególne znaczenie, gdyż wiadomo, że pominięcie którejkolwiek z czynności w procedurze skaka-

nia ze spadochronem może zakończyć się tragicznie.

Słowem kluczowym poprzedniego akapitu jest „procedura”. Określa ono wydzielony z programu

ciąg instrukcji, któremu nadano nazwę. Nazwa służy do uruchamiania takiego ciągu instrukcji (czyli

procedury) w dowolnej części programu. Visual Basic 2010 pozwala na tworzenie kilku typów proce-

dur. Bieżący rozdział omawia jedynie dwa z nich – podprogramy i funkcje – określane wspólnym mia-

nem metod.

VI.1.

Podprogramy – metody typu Sub

Załóżmy, że programista chciałby, aby każdy jego program rozpoczynał swoją pracę od przed-

stawienia pewnych danych.

Przykład.

********************************************
* *
* Program wykonał: Imię Nazwisko *
* adres e-mail: konto@serwer *
* *
********************************************

Naciśnij Enter, aby kontynuować...

Napisanie kodu źródłowego, który wykona taką winietę nie nastręcza żadnych kłopotów – wy-

starczy użyć instrukcji WriteLine i ReadLine konsoli. Jednak pisanie takiego kodu, a nawet kopiowa-

nie go wymaga czasu. Kolejne ćwiczenie będzie polegać na napisaniu kodu realizującego przedsta -

wienie danych o autorze projektu.

Ćwiczenie 60
Utworzyć Projekt_060 aplikacji konsolowej, która przedstawi dane autora aplikacji w
sposób podobny do przedstawionego w przykładzie powyżej (użyć własnych danych –
imię, nazwisko i e-mail).

Aplikacja wykonuje winietę przedstawiając dane autora projektu.

Aby uniknąć ciągłego przepisywania instrukcji kodu w kolejnym ćwiczeniu utworzony zostanie

podprogram – procedura typu Sub, której podstawowa postać wygląda następująco:

Sub NazwaPodprogramu()

‘Instrukcje

End Sub

Ćwiczenie 61
Dodać do Projekt_060 moduł o nazwie Moje_060 i zdefiniować w nim procedurę Sub o
nazwie Winieta, w której bloku znajdą się instrukcje przeniesione z procedury Main.

1. Dodaj do Projekt_060 moduł Moje_060 (wykorzystaj schemat wprowadzony w ćwiczeniu

18.).

2. Utwórz w dodanym module szkielet procedury Winieta, w tym celu:

◦

wpisz słowo kluczowe Sub, rozpoczynające deklarację podprogramu i dopisz spa-

cję,

◦

wpisz nazwę procedury – Winieta i naciśnij Enter. Zauważ, że edytor wspomaga

tworzenie procedur, dodając po nazwie parę nawiasów okrągłych oraz słowa klu-

czowe End Sub kończące blok podprogramu. Kursor tekstowy znajduje się we-

wnątrz bloku.

3. Przenieś wszystkie instrukcje z procedury Main do procedury Winieta.

4. Sprawdź działanie aplikacji.

Aplikacja nie wykonuje winiety, gdyż podprogram nie został uruchomiony. Istnieją dwa sposoby

uruchamiania podprogramów. Pierwszy, tradycyjny, polega na użyciu słowa kluczowego Call (Wołaj,

przywołaj), a po nim nazwy podprogramu.

Przykład.

Call Podprogram()

Druga, najczęściej współcześnie stosowana, polega na użyciu nazwy podprogramu tak, jak

zwykłej instrukcji języka.

Przykład.

Podprogram()

Kolejne ćwiczenie polegać będzie na wywołaniu podprogramu Winieta w procedurze Main.

Ćwiczenie 62
Uruchomić podprogram Winieta w procedurze Main.

1. Wpisz w procedurze Main instrukcję Winieta().

2. Sprawdź działanie aplikacji.

Każdy projekt, do którego programista dołączy moduł Moje_060 będzie mógł wykorzystać pro-

cedurę Winieta. Obrazuje to kolejne ćwiczenie.

Ćwiczenie 63
Utworzyć Projekt_063 aplikacji konsolowej. Dodać do niego moduł Moje_060 i wywołać
w procedurze Main podprogram Winieta. Sprawdzić działanie aplikacji.

1. Utwórz nowy projekt aplikacji konsolowej.

2. Dodaj do projektu moduł Moje_060, w tym celu:

◦

wykorzystaj polecenie Add Existing Item (Dodaj istniejący element) zawarte w

menu Project (polecenie dostępne także w grupie poleceń Add menu podręczne-

go projektu w oknie Solution Explorer); polecenie posiada skrót klawiaturowy –

Ctrl+D; otwiera ono okno Add Existing Item będące kopią systemowego okna

Otwieranie,

◦

odszukaj folder Projekt_060, a w nim plik modułu Moje_060 i zaznacz go,

◦

zatwierdź wybór przyciskiem Add.

3. Zauważ, że w oknie Solution Explorer pojawił się plik Moje_060.vb (jest to kopia pliku za -

wartego w Projekt_060).

4. Sprawdź kod źródłowy modułu Moje_060.

5. Wywołaj w procedurze Main procedurę Winieta.

6. Sprawdź działanie aplikacji.

Aplikacja Projekt_063 „przedstawia się” identycznie jak aplikacja Projekt_060. Tworzenie kopii

pliku pozwala programistom edytować moduły niezależnie.

Jeśli programista otrzyma nowy adres e-mail (np. po zmianie miejsca pracy) , to będzie zmu -

szony do edycji procedury Winieta. Podobnie będzie przy zmianie nazwiska (współcześnie, zjawi-

sko to, dotyczy tak kobiet, jak i mężczyzn). Problem ten rozwiązuje się poprzez zdefiniowanie para-

metrów podprogramu.

Parametry pozwalają na przekazanie do podprogramu wartości wpływających na sposób wyko-

nania podprogramu. Rzeczywistym przykładem może być obliczanie kwadratu liczby. Wiadomo, że

aby obliczyć kwadrat liczby, należy pomnożyć ją przez taką samą wartość. Przykładowo, 2

2

=2*2.

W matematyce zapis ten uogólnia się podając wzór: x

2

=x*x. We wzorze tym, x jest parametrem (ar-

gumentem) funkcji kwadratowej. Znając ten wzór można obliczyć kwadrat dowolnej liczby.

Parametry procedury

Miejscem definiowania parametrów jest wnętrze pary nawiasów okrągłych występujących

po nazwie podprogramu. Parametry pozwalają przekazywać do podprogramu pewne dane w chwili

jego wywołania. Podprogram, któremu przekazano dane poprzez parametry wykorzystuje je w trakcie

działania. Istnieją dwa sposoby przekazywania danych do podprogramu:

przez wartość (ang. by value),

przez referencję (ang. by reference).

Objaśnienie różnicy pomiędzy tymi sposobami nastąpi w podpunkcie dotyczącym parametrów

przekazywanych przez referencję, do tego czasu wykorzystywany będzie jedynie pierwszy z nich.

Parametry przekazywane przez wartość

Deklaracja parametru przekazywanego przez wartość wygląda następująco:

ByVal NazwaParametru As TypParametru

Słowo kluczowe

ByVal

(skrót od by value) można opuścić, gdyż jest to domyślny sposób prze-

kazywania parametrów i edytor doda je automatycznie. Jeśli programista definiuje więcej niż jeden

parametr, to deklaracje rozdziela się przecinkiem.

Przykład.

ByVal NazwaParametru1 As TypParametru1, ByVal NazwaParametru2 As TypParametru2

Kolejne ćwiczenie będzie polegać na zdefiniowaniu dwóch parametrów w procedurze Winieta,

posłużą one do przekazywania do procedury nazwiska i adresu e-mail.

Ćwiczenie 64
Zdefiniować w procedurze Winieta parametry Nazwisko i Email typu String
przekazywane przez wartość.

1. Umieść kursor tekstowy wewnątrz pary nawiasów występujących po słowie Winieta w

module Moje_060.

2. Zdefiniuj parametr Nazwisko typu String przekazywany przez wartość, w tym celu:

◦

wpisz słowo ByVal i dopisz spację,

◦

wpisz nazwę parametru – Nazwisko i dopisz spację,

◦

określ typ parametru – As String.

Przykład.

ByVal Nazwisko As String

3. Zdefiniuj drugi parametr – Email typu String, w tym celu:

◦

wpisz przecinek po słowie String określającym typ parametru Nazwisko i dopisz spa-

cję,

◦

nie wpisuj słowa kluczowego ByVal – automatycznie doda je edytor,

◦

wpisz nazwę parametru – Email – dopisz spację i określ typ parametru.

4. Przenieś kursor tekstowy do innego miejsca kodu i zauważ, że słowo kluczowe ByVal zo-

stało dodane przed deklaracją parametru Email.

5. Spróbuj uruchomić aplikację.

6. Zamknij przyciskiem Nie (No) komunikat o błędach w trakcie kompilacji.

Wywołanie procedury musi spełniać wymagania postawione w jej deklaracji. Procedura Wini-

eta posiada dwa parametry i tyle musi również zawierać jej wywołanie. Edytor jest w tym zakresie

niezwykle pomocny – w trakcie wpisywania do kodu źródłowego wywołania procedury „podpowiada”

jakich wymaga ona parametrów. Obrazuje to kolejne ćwiczenie.

Ćwiczenie 65
Wprowadzić wartości parametrów do wywołania procedury Winieta.

1. Ustaw kursor tekstowy wewnątrz pary nawiasów okrągłych w wywołaniu podprogramu

Winieta w procedurze Main.

2. Naciśnij klawisz Delete (Usuń) i zauważ, że edytor wyświetla informację o wymaganych

parametrach podprogramu podając ich nazwy i typy. Jest to sytuacja analogiczna do tej,

jaka nastąpiłaby podczas wprowadzania nazwy podprogramu po wprowadzeniu lewego

nawiasu okrągłego.

Przykład.

3. Wpisz w cudzysłowie ciąg znaków "NoweNazwisko" – będzie to wartość parametru Na-

zwisko przekazana do podprogramu.

4. Wpisz przecinek, a po nim w cudzysłowie ciąg znaków "Nowy E-mail" – będzie to war-

tość parametru Email przekazana do podprogramu.

5. Sprawdź działanie aplikacji.

Projekt został skompilowany, a aplikacja uruchomiona. Jednak w winiecie nie pojawiły się tek-

sty: NoweNazwisko i Nowy E-mail. Podprogram wprawdzie otrzymał poprzez parametry wspomniane

łańcuchy znaków, ale z nich nie korzysta. Przed wykonaniem kolejnego ćwiczenia, które ten błąd na-

prawi należy powiedzieć, że z parametrów podprogramu można (wewnątrz bloku podprogramu) ko -

rzystać tak, jak ze zmiennych.

Ćwiczenie 66
Użyć wartości parametrów Nazwisko i Email w podprogramie Winieta.

1. Zmodyfikuj wywołanie procedury WriteLine wypisującej wiersz z nazwiskiem tak, aby wy-

korzystywała wartość parametru Nazwisko.

Przykład. Procedurę Lset (patrz: Funkcje działające na łańcuchach znaków, podrozdział II.9)

użyto aby uwzględnić fakt, że nazwiska mogą mieć różną długość, co nie powinno mieć wpływu na

wygląd ramki z gwiazdek.

Console.WriteLine("* Program wykonał: Imię {0}*", LSet(Nazwisko, 15))

2. Zmodyfikuj wywołanie procedury WriteLine wypisującej wiersz z adresem e-mail tak, aby

wykorzystywała wartość parametru Email (weź pod uwagę zmienną długość adresu).

3. Sprawdź działanie aplikacji.

Prześledźmy działanie programu. Aplikacja, po wywołaniu procedury Winieta, tworzy dla niej

zmienne typu

String

o nazwach Nazwisko i Email, następnie oblicza wartości parametrów, które

w ogólności mogą być wyrażeniami, i przypisuje wyniki do utworzonych zmiennych. Kolejnym kro-

kiem jest wykonanie instrukcji podprogramu. Ponieważ zmienne posiadają wartości pobrane z ze -

wnątrz, to każde wywołanie podprogramu może dać inny efekt w zależności od wartości parametrów

podanych w wywołaniu. Parametry podprogramu „żyją” tylko tak długo, jak długo wykonywany jest

podprogram. Zmiana wartości parametru wewnątrz podprogramu nie wpływa zatem na zmienne zde-

finiowane na zewnątrz.

Wspomniano, że dane przekazywane przez wartość mogą być wyrażeniami tak, jak w poniż-

szym przykładzie (zakłada się, że zmienne strKonto i strSerwerPoczty są typu String i zawierają od -

powiednie łańcuchy tekstowe):

Winieta("Nowenazwisko", strKonto & "@" & strSerwerPoczty)

Opis działania aplikacji będzie identyczny z poprzednim. Ponownie aplikacja tworzy zmienne

podprogramu – Nazwisko i Email – następnie pobiera wartość pierwszego parametru wywołania i

przypisuje ją pierwszej zmiennej. Kolejnym krokiem jest obliczenie wartości wyrażenia:

strKonto & "@" & strSerwerPoczty

Obliczona wartość – łańcuch tekstowy, np. "[e-mail]" – zostaje przypisana zmien-

nej podprogramu o nazwie Email. Obie zmienne mogą być następnie wykorzystane w trakcie działa -

nia podprogramu.

Aby odróżnić parametry określone w deklaracji podprogramu od wartości (wyrażeń) podawa-

nych w instrukcji wywołującej podprogram, te pierwsze nazywa się parametrami formalnymi, a te dru-

gie parametrami aktualnymi.

Należy podkreślić jeszcze jeden ważny problem. Jeśli jako parametr wywołania podprogramu

zostanie podana zmienna (zakłada się, że w procedurze Main zadeklarowano zmienne Nazwisko i

Adres oraz nadano im odpowiednie wartości):

Winieta(Nazwisko, Adres)

to w dalszym ciągu, aplikacja tworzy nową zmienną Nazwisko (a także Email), która jest zmien-

ną podprogramu i nie jest tożsama ze zmienną Nazwisko zadeklarowaną w procedurze Main. Jedy-

ne co je łączy, to to, że wartość zmiennej Nazwisko z procedury Main zostanie pobrana i przypisana

zmiennej Nazwisko z podprogramu Winieta. Jakakolwiek zmiana wartości zmiennej Nazwisko

w procedurze Winieta nie ma wpływu na wartość zmiennej Nazwisko w procedurze Main.

Zdarza się jednak, że zachodzi potrzeba, aby podprogram zmieniał wartość zmiennej, którą

przekazano mu jako parametr. Zagadnienie to omawia kolejny podpunkt.

Parametry przekazywane przez referencję

Deklaracja parametru przekazywanego przez referencję wygląda następująco:

ByRef NazwaParametru As TypParametru

Słowa kluczowego

ByRef

(skrót od by reference) nie można opuścić, gdyż w takim przypadku

edytor doda automatycznie słowo kluczowe

ByVal

. Angielskie słowo reference oznacza wzmiankę,

odesłanie (np. odsyłacz do literatury), wskazanie.

Jeśli w wywołaniu procedury, w miejscu parametru zdefiniowanego ze słowem

ByRef

, progra-

mista umieści nazwę zmiennej, nazwę pola zmiennej typu strukturalnego, nazwę komórki tablicy, ge-

neralnie – nazwę każdego elementu, którego wartość można modyfikować w programie, to zmiany

wartości parametru wewnątrz podprogramu będą miały wpływ na wartość tego elementu w progra-

mie.

W przypadku, gdy programista umieści wyrażenie, lub nazwę elementu, którego wartości nie

można zmienić w programie, np. stałej, elementu enumeracji itp., możliwe będzie jedynie zmienianie

wartości zmiennej w podprogramie tak, jak to miało miejsce dla parametrów przekazywanych przez

wartość. Kolejne ćwiczenie zapoznaje z definiowaniem parametrów przekazywanych przez referen-

cję.

Ćwiczenie 67
Zdefiniować procedurę PobierzLiczbę o jednym parametrze PobieranaLiczba typu
Integer przekazywanym przez referencję i dwóch parametrach Min i Maks typu Integer
przekazywanych przez wartość. Procedura powinna wyświetlać zachętę do
wprowadzania liczby całkowitej z przedziału <Min, Maks> i nie powinna pozwalać na
wprowadzenie liczby leżącej na zewnątrz tego przedziału (wykorzystać pętlę z
warunkiem sprawdzanym na końcu).

1. Dodaj pusty wiersz w module Moje_060 po słowach End Sub kończących procedurę Wi-

nieta. Treść procedury Winieta można zwinąć używając przełącznika zwiń/rozwiń.

2. Utwórz szkielet deklaracji procedury PobierzLiczbę wpisując słowo kluczowe Sub, po

spacji nazwę procedury i naciskając Enter.

3. Zdefiniuj, wewnątrz pary nawiasów okrągłych dodanych przez edytor po nazwie procedu-

ry, parametr PobieranaLiczba typu Integer przekazywany przez referencję, w tym celu:

◦

wpisz słowo kluczowe ByRef (nie wolno go pominąć) i dopisz spację,

◦

wpisz nazwę parametru – PobieranaLiczba – i określ jego typ.

4. Zdefiniuj parametr Min typu Integer (nie musisz wpisywać słowa kluczowego ByVal).

5. Zdefiniuj parametr Maks typu Integer.

6. Zbuduj wewnątrz procedury pętlę Do … Loop z warunkiem sprawdzanym na końcu, pętla

powinna być wykonywana tak długo, aż wartość zmiennej PobieranaLiczba będzie

w przedziale <Min, Maks>.

7. Zaprogramuj wewnątrz pętli wyświetlanie zachęty do wprowadzenia wartości z przedzia-

łu <Min, Maks> oraz pobieranie od użytkownika wartości i przypisywanie jej zmiennej Po-

bieranaLiczba.

8. Skompiluj projekt.

Zdefiniowana procedura może mieć następującą postać:

Tylko parametr PobieranaLiczba może posłużyć do przekazania wartości na zewnątrz procedu-

ry PobierzLiczbę. Aby użyć tej możliwości, jako pierwszy parametr wywołania musi wystąpić ele-

ment zmienny, np. zmienna programu, komórka tabeli itp. Kolejne ćwiczenie pokaże zmianę wartości

zmiennej programu po wywołaniu procedury z parametrem przekazywanym przez referencję.

Rysunek 24: Jedna z możliwych postaci procedury PobierzLiczbę.

Ćwiczenie 68
Użyć parametru przekazywanego przez referencję do zmiany wartości zmiennej na
zewnątrz procedury.

1. Zadeklaruj w procedurze Main zmienną intLiczba typu Integer o wartości początkowej 9.

2. Wywołaj procedurę PobierzLiczbę z parametrami: intLiczba, 10, 15.

3. Zaprogramuj wyświetlenie w konsoli wartości zmiennej intLiczba.

4. Sprawdź działanie aplikacji.

Aplikacja wyświetla winietę, pobiera liczbę z przedziału <10, 15> i wyświetla wartość zmiennej

intLiczba, która nie wynosi 9. Działanie aplikacji jest odmienne od tego, które występuje dla parame -

trów przekazywanych przez wartość. Zmienna intLiczba zadeklarowana w procedurze Main zajmuje

w pamięci operacyjnej określone miejsce (posiada adres). W chwili wywołania procedury Pobierz-

Liczbę (oprócz zmiennych Min i Max) tworzona jest zmienna PobieranaLiczba. Jest to zmienna re-

ferencyjna. Referuje ona (wskazuje, odwołuje się) do tego samego miejsca w pamięci operacyjnej,

które zostało przydzielone w celu przechowywania wartości zmiennej intLiczba. Występuje zatem

taka sytuacja, że dwie zmienne przechowują swoją wartość w tym samym miejscu pamięci operacyj-

nej. Jeśli wartość zmiennej PobieranaLiczba zmieni się, to jest to jednoznaczne ze zmianą wartości

zmiennej intLiczba.

Procedura PobierzLiczbę służy do wprowadzania liczb z określonego przedziału i jest dosyć

ogólna, gdyż pozwala podać granice przedziału jako parametry wywołania (Min, Maks). Załóżmy, że

procedura ta ma zostać wykorzystana wielokrotnie w programie, i w 95% wywołań górne ogranicze -

nie – Maks – wynosi 215. Jeśli wywołań jest 100, to programista będzie musiał wpisać 95 razy liczbę

215 i 25 razy inną liczbę. Problem ten został rozwiązany przez parametry opcjonalne.

Parametry o wartości domyślnej – opcjonalne

Parametry o wartości domyślnej tak, jak zwykłe parametry służą do przekazywania pewnych

wartości do procedury. Charakteryzują się tym, że jeśli programista nie określi, podczas wywołania

procedury, wartości parametru – pominie go, to procedura nada zmiennej wartość domyślną określo-

ną w deklaracji procedury. W tym zakresie występuje ograniczenie, a mianowicie, parametry domyśl-

ne muszą występować na liście parametrów jako ostatnie. Deklaracja parametru opcjonalnego ma

następującą postać:

Optional ByVal NazwaParametru As TypParametru = WartośćDomyślna

lub

Optional ByRef NazwaParametru As TypParametru = WartośćDomyślna

Jeśli w wywołaniu procedury, w miejscu parametru NazwaParametru nie występuje wartość, to

zmiennej NazwaParametru, w procedurze, zostanie przypisana wartość początkowa WartośćDomyśl-

na. Definiowanie parametru opcjonalnego przedstawia kolejne ćwiczenie.

Ćwiczenie 69
Ustalić wartość domyślną parametru Maks na 215.

1. Ustaw kursor tekstowy przed słowem kluczowym ByVal rozpoczynającym deklarację pa-

rametru Maks i dopisz słowo kluczowe Optional (opcjonalny), następnie ustaw kursor po

określeniu typu parametru i dopisz operator przypisania i liczbę 215.

2. Skompiluj projekt.

Pominięcie parametru w chwili wywołania procedury należy traktować dosłownie. Załóżmy, że

wywołanie procedury PobierzLiczbę ma postać:

PobierzLiczbę(intLiczba, 10, 15)

W wywołaniu tym parametr Maks ma wartość 15, pominięcie, oznacza usunięcie go z wywoła-

nia:

PobierzLiczbę(intLiczba, 10, )

Liczba parametrów opcjonalnych może być większa. W kolejnym ćwiczeniu ustala się wartość

domyślną parametru Min na 0.

Ćwiczenie 70
Ustalić wartość domyślną parametru Min na 0.

Procedura PobierzLiczbę ma już dwa parametry domyślne. Parametry domyślne można po-

mijać pojedynczo, lub wszystkie, lub dowolną ich kombinację. Jeśli programista chce pominąć tylko

parametr Min, a nadać wartość 100 parametrowi Maks, to musi to zrobić następująco:

PobierzLiczbę(intLiczba, , 100)

Przecinki wskazują miejsce pominiętego parametru. Przy tym, jeśli pomija się grupę parame-

trów leżących na końcu listy, to przecinków można nie wpisywać. Np. pomijając ostatni parametr

można użyć wywołania:

PobierzLiczbę(intLiczba, 10)

a pomijając dwa ostatnie:

PobierzLiczbę(intLiczba)

Kolejne ćwiczeniu pokazuje różne wywołania z uwzględnieniem parametrów opcjonalnych.

Ćwiczenie 71
Wykorzystać procedurę PobierzLiczbę i różne kombinacje jej parametrów opcjonalnych.

1. Skopiuj dwa wiersze: wywołanie procedury PobierzLiczbę i instrukcję wypisującą wartość

intLiczba w konsoli.

2. Wklej skopiowane wiersze pięć razy na końcu procedury Main.

3. Usuń liczbę 15 z pierwszego wywołania (pozostaw przecinek po liczbie 10).

4. Usuń liczbę 15 oraz poprzedzający ją przecinek z drugiego wywołania.

5. Usuń liczbę 10 z trzeciego wywołania.

6. Usuń liczby 10 i 15 z czwartego wywołania (pozostaw przecinki).

7. Usuń liczby 10 i 15 oraz przecinki z piątego wywołania.

8. Sprawdź działanie aplikacji.

Procedura PobierzLiczbę służy do pobierania liczby całkowitej z określonego przedziału.

Może się okazać, że aplikacja równie często (np. 150 razy) pobiera liczbę rzeczywistą z ograniczone-

go zakresu i programista chciałby użyć funkcji o takiej samej nazwie – PobierzLiczbę, ale do po-

bierania liczb rzeczywistych. Problem ten rozwiązuje mechanizm przeciążania.

Przeciążanie procedur

Każdą procedurę charakteryzuje jednoznacznie pierwszy wiersz jej deklaracji:

Sub Nazwa (Parametr1, Parametr2)

Nazwa procedury oraz liczba, typ i kolejność parametrów (bez opcjonalnych) stanowią zestaw

informacji nazywany sygnaturą procedury. Dwie procedury są różne (to znaczy jednoznacznie rozpo-

znawalne przez kompilator) jeśli posiadają różne sygnatury. Oznacza to, że procedury są różne, jeśli

ich sygnatury różnią się przynajmniej jednym elementem, np. typem trzeciego parametru, liczbą pa-

rametrów itd. Można zatem zbudować dwie procedury o identycznej nazwie, które będą jednak róż -

ne.

Opisany mechanizm nazywa się przeciążaniem, a zdefiniowane w ten sposób procedury –

przeciążonymi. Przeciążanie zilustruje kolejne ćwiczenie.

Ćwiczenie 72
Utworzyć przeciążoną procedurę PobierzLiczbę, która będzie pobierać liczbę rzeczywistą
z określonego przedziału.

1. Skopiuj deklarację procedury PobierzLiczbę i wklej kopię poniżej oryginału. Zauważ, że

nazwa pierwszej „wersji” została podkreślona, a po naprowadzeniu na nią kursora myszy

edytor podpowiada, że:

Public Sub PobierzLiczbę(ByRef PobieranaLiczba As Integer, [Min As Integer = 0], [Maks As In-

teger = 215])' has multiple definitions with identical signatures. – Publiczna procedura PobierzLiczbę

posiada wiele deklaracji z identycznymi sygnaturami.

2. Zmień typ wszystkich parametrów w drugim egzemplarzu procedury z Integer na Double.

Zauważ, że po zmianie typu pierwszego parametru znika błąd sygnalizowany w punkcie

1. ćwiczenia.

3. Zmień tekst zachęty tak, aby użytkownik wiedział, że może wprowadzić liczbę rzeczywi -

stą.

4. Zmień funkcję konwersji CInt na Cdbl.

5. Skompiluj projekt.

Kompilator odróżnia od siebie dwie wersje procedury PobierzLiczbę. Programista może wy-

wołać każdą z nich używając tej samej nazwy. Jeśli użyje jako pierwszego parametru wielkości typu

Integer

, to zostanie użyta jedna wersja, jeśli

Double

– druga. Edytor wspiera programistę wyświetla-

jąc informację o wywoływanej procedurze w specyficzny sposób. Ilustruje to kolejne ćwiczenie.

Ćwiczenie 73
Wykorzystać procedurę PobierzLiczbę do pobrania wartości rzeczywistej.

1. Dodaj na końcu procedury Main pusty wiersz i ustaw w nim kursor tekstowy.

2. Zadeklaruj zmienną dblLiczba typu Double o wartości początkowej 7.

3. Zaprogramuj użycie przeciążonej wersji procedury PobierzLiczbę do pobrania wartości

dla zmiennej dblLiczba, w tym celu:

◦

wpisz nazwę procedury – PobierzLiczbę – i dopisz lewy nawias okrągły,

◦

zauważ, że edytor nieco inaczej przedstawia informację o procedurze i jej parame-

trach:

Rysunek 25: Dodatkowa informacja o istnieniu przeciążonych wersji metody PobierzLiczbę.

◦

użyj klawisza ze strzałką () do wyświetlenia informacji o drugiej wersji procedury:

◦

wpisz nazwę zmiennej dblLiczba i zamknij nawias okrągły.

4. Zaprogramuj wyświetlenie wartości zmiennej dblLiczba.

5. Sprawdź działanie aplikacji.

Kończenie pracy procedury

Działanie procedury kończy się wraz z wykonaniem jej ostatniej instrukcji. Może się jednak oka-

zać, że po wykonaniu pewnej instrukcji procedury dalsza jej praca jest niepotrzebna, albo wręcz

szkodliwa. W takim przypadku do zakończenia procedury można użyć jednej z dwóch instrukcji:

Exit Sub 'Wyjdź z procedury
Return 'Powrót

Liczba wystąpień każdej z tych instrukcji nie jest ograniczona i można je stosować w tej samej

procedurze.

Przykład. Procedura pobiera współczynniki a, b, c równania kwadratowego:

ax

2



bxc=0

Jeśli użytkownik wprowadzi dla a wartość 0, to pobieranie dalszych danych nie ma sensu.

Sub PobierzABC(ByRef a As Double, ByRef b As Double, ByRef c As Double)

Console.Write("Współczynnik a równania wynosi: ")
a = CDbl(Console.ReadLine())
If a = 0 Then Exit Sub
'Dalsze instrukcje

End Sub

Wydaje się, że użycie instrukcji

Exit Sub

, ze względu na słowo kluczowe

Sub

jest bardziej

wskazane – poprawia czytelność kodu. Ponadto słowo

Return

ma szczególne znaczenie dla drugie-

go typu metod, to jest funkcji.

VI.2.

Funkcje – metody typu Function

W wielu programach, albo w wielu miejscach jednego programu, może pojawić się ciąg instruk-

cji, których zadaniem jest obliczenie pewnej wartości. Podobnie, jak dla podprogramów, istnieje moż-

liwość nadania takiemu ciągowi nazwy. Ponieważ efektem wykonania nazwanego zestawu instrukcji

jest raczej określony wynik (wartość funkcji), a nie określony ciąg działań (jak w przypadku procedur),

to procedura taka może być traktowana jako wartość, którą zwraca – może wystąpić po prawej stro-

Rysunek 26: Informacja o sygnaturze drugiej wersji metody PobierzLiczbę.

nie operatora przypisania. Każda funkcja posiada listę parametrów podlegających takim samym za -

sadom jak w procedurach typu

Sub

, ponadto rozważania dotyczące sygnatur i przeciążania przeno-

szą się z procedur na funkcje bez zmian. Podstawowa postać deklaracji funkcji jest następująca:

Function NazwaFunkcji(Parametry) As TypWynikuFunkcji

'Instrukcje funkcji, w tym przynajmniej jedna:
'Return Wyrażenie
'lub
'NazwaFunkcji = Wyrażenie

End Function

Słowa kluczowe

Function

…

End Function

ograniczają blok instrukcji funkcji. Instrukcja

Return

Wyrażenie służy do przekazania wyniku funkcji procedurze wywołującej. Do tego celu moż-

na użyć również przypisania:

NazwaFunkcji = Wyrażenie

Różnica pomiędzy tymi sposobami jest taka, że pierwszy z nich (Return) kończy działanie bloku

funkcji. W drugim przypadku do zakończenia funkcji można użyć instrukcji

Exit

Function

. Kolejne

ćwiczenie polegać będzie na zdefiniowaniu funkcji, która oblicza wartość wyrazu ciągu:

a

n

=

2n−1

n1

na podstawie wartości n przekazanej jako parametr. Należy zauważyć, że ze względu na uła-

mek występujący we wzorze, wartość wyrazu ciągu, w ogólności, będzie liczbą rzeczywistą.

Ćwiczenie 74
Zdefiniować funkcję WyrazCiągu, która na podstawie parametru n (numeru wyrazu)
oblicza jego wartość.

1. Dodaj pusty wiersz w module Moje_060 i umieść w nim kursor tekstowy.

2. Zdefiniuj funkcję spełniającą postulaty postawione w zadaniu, w tym celu:

◦

wpisz słowo kluczowe Function, a po spacji nazwę funkcji – WyrazCiągu,

◦

otwórz nawias okrągły i zdefiniuj parametr n typu Integer przekazywany przez

wartość i zamknij nawias okrągły,

◦

określ typ wyniku funkcji na Double i naciśnij Enter,

◦

zauważ, że edytor zamyka deklarację funkcji słowami kluczowymi End Func-

tion i umieszcza kursor tekstowy wewnątrz bloku instrukcji.

Przykład.

Function WyrazCiągu(ByVal n As Integer) As Double

End Function

3. Zaprogramuj obliczenie wartości wyrazu ciągu i przekazanie jej jako wyniku funkcji,

w tym celu:

◦

wpisz słowo Return i dopisz spację,

◦

wpisz wyrażenie obliczające wartość wyrazu ciągu na podstawie wzoru podanego

przed ćwiczeniem.

Przykład.

Return (2 * n – 1) / (n + 1)

4. Skompiluj projekt.

Deklaracja funkcji może mieć następującą postać:

Procedurę typu

Function

można wywołać tak, jak procedurę typu

Sub

, jednak w takim przy-

padku następuje utrata wyniku funkcji. Aby nie dopuścić do takiej sytuacji wywołuje się funkcje

po prawej stronie znaku przypisania, lub w jakimkolwiek innym miejscu kodu, w którym można umie-

ścić wartość określonego typu.

Przykłady. Zakłada się, że zmienna dblWyraz jest typu

Double

.

dblWyraz = WyrazCiągu(7)
Console.WriteLine("Wyraz ciągu o numerze {0} ma wartość {1}", 11, WyrazCiągu(11))

Kolejne ćwiczenie wykorzystuje funkcję WyrazCiągu do wypełnienia wartościami tablicy.

Ćwiczenie 75
Utwórz nowy Projekt_075 aplikacji konsolowej i dodaj do niego moduł Moje_060. Użyj
funkcji WyrazCiągu do wypełnienia, wartościami pierwszych pięciu wyrazów ciągu,
tablicy o elementach typu Double. Zaprogramuj wyświetlenie numerów wyrazów i ich
wartości w postaci tabelki w konsoli.

Efekt działania aplikacji może być podobny do przedstawionego poniżej. Wartości wyrazów cią-

gu formatowano funkcją Format, a wyrównanie uzyskano przy użyciu funkcji RSet.

Rysunek 28: Projekt_075 w działaniu.

Rysunek 27: Kod źródłowy funkcji WyrazCiągu.

Funkcje można wywoływać w innych funkcjach, a także w procedurach. Również procedury

można wywoływać w funkcjach lub innych procedurach. Podział funkcji (procedur) na mniejsze funk-

cje (procedury), w oparciu o logiczne przesłanki, połączony z używaniem znaczących nazw dla funk-

cji i procedur powoduje, że kod źródłowy jest czytelny i zwarty – łatwiej odnaleźć w nim potencjalne

błędy.

Funkcję (procedurę) można wywołać także w niej samej – wywołując zjawisko zwane rekuren-

cją.

VI.3.

Rekurencja

Sztandarowym przykładem rekurencji jest matematyczna definicja funkcji silnia:

n !=

{

1 gdy n=0

n⋅n−1 ! gdy n0

Łatwo zauważyć, że funkcja silnia zdefiniowana jest przez samą siebie, to znaczy, aby obliczyć

n! trzeba najpierw obliczyć (n-1)!. Żeby móc obliczyć (n-1)! trzeba wcześniej obliczyć (n-2)! itd. Mo-

głoby się wydawać, że taka deklaracja jest nieskuteczna – „tak można w nieskończoność”. Jednak

oblicza się wartość funkcji silnia, gdyż występuje pewien przypadek elementarny, który kończy obli-

czenia. Koniec obliczeń następuje wtedy, gdy kolejnym argumentem funkcji silnia jest zero. Wtedy

funkcja zwraca wartość 1. Wartość ta mnożona jest przez poprzedni argument, a iloczyn przez po-

przedni itd., aż do osiągnięcia pierwszego wywołania, które zwraca obliczoną wartość.

Prześledźmy to na przykładzie 3!

A) 3

≠

0, dlatego musimy obliczyć (3-1)!, czyli 2!, a wynik pomnożyć przez 3,

B) 2

≠

0, dlatego musimy obliczyć (2-1)!, czyli 1!, a wynik pomnożyć przez 2,

C) 1

≠

0, dlatego musimy obliczyć (1-1)!, czyli 0!, a wynik pomnożyć przez 1,

D) 0=0, z definicji 0! wynosi 1, wartość 1 jako wynik przekazujemy do wiersza C),

E) 1 pomnożone przez 1 daje 1, wartość tą, jako wynik przekazujemy do wiersza B),

F) 1 pomnożone przez 2 daje 2, wartość tą, jako wynik przekazujemy do wiersza A),

G) 2 pomnożone przez 3 daje 6, wartość tą, jako wynik funkcji przekazujemy do miejsca wywo-

łania.

3!=6.

W kolejnym ćwiczeniu nastąpi próba zdefiniowania rekurencyjnego funkcji silnia. Przyjrzyjmy się

jeszcze raz definicji:

n !=

{

1 gdy n=0

n⋅n−1 ! gdy n0

Można ją odczytać następująco: Jeśli argument (parametr) funkcji jest równy zero, to funkcja

zwraca wartość 1, jeśli jest większy niż zero funkcja zwraca wartość iloczynu argumentu i wartości

funkcji silnia dla argumentu pomniejszonego o jedność. Ponieważ występują dwa przypadki n=0 i

n>0, to wydaje się, że blok funkcji może zawierać konstrukcję warunkową

If

…

Then

…

Else

…

End If

. Warunek powinien być wyrażeniem sprawdzającym czy argument jest równy zeru. Naszki-

cujmy szkielet funkcji:

Function Silnia(ByVal n As Integer) As Integer

If n = 0 Then

Else

End If

End Function

Zdanie: Jeśli argument (parametr) funkcji jest równy zero, to funkcja zwraca wartość 1, tłuma-

czy się na język programowania bardzo prosto:

Return 1

Również drugie zdanie: Jeśli argument (parametr) funkcji jest większy niż zero, to funkcja zwra-

ca wartość iloczynu argumentu i wartości funkcji dla argumentu pomniejszonego o jedność, można

łatwo przetłumaczyć:

Return n * Silnia(n – 1)

W ostateczności funkcja przyjmie postać:

Function Silnia(ByVal n As Integer) As Integer

If n = 0 Then

Return 1

Else

Return n * Silnia(n – 1)

End If

End Function

Ćwiczenie 76
Utworzyć nowy projekt aplikacji konsolowej i zdefiniować w jego części deklaracyjnej
funkcję Silnia. Zaprogramować obliczenie i wyświetlenie pierwszych sześciu wartości
funkcji.

Rysunek 29: Projekt_076 w działaniu.

Funkcja Silnia, której typ zdefiniowano na

Integer

nie pozwala obliczać wartości n! dla n więk-

szych niż 12. Można to poprawić zmieniając typ wyniku na Int64 (n <= 20). Jeśli nie zależy nam na

dokładnej wartości całkowitej, to można zwiększyć możliwości funkcji stosując typy rzeczywiste:

Sin-

gle

– n <= 34,

Double

– n <= 170. Przy tym, w przypadku typów rzeczywistych, przekroczenie poda-

nego zakresu powoduje, że wynik zwracany przez funkcję to „+nieskończoność”.

W matematyce występuje wiele deklaracji, które można zaimplementować rekurencyjnie. Kolej-

nym przykładem jest funkcja obliczająca wartość tzw. Symbolu Newtona. Z czworga dzieci można

wybrać sześć różnych par:

1 2

1 3

1 4

2 3

2 4

3 4

Liczbę możliwych do ustawienia, różnych układów składających się z k elementów, przy wybo-

rze ze zbioru n elementów określa właśnie funkcja Symbol Newtona (



n
k



– czyta się „n nad k”)

określona wzorem:



n
k



=

n !

k !⋅ n−k !

Pamiętając, że 0! jest równe 1, można zauważyć, że jeśli k jest równe zeru, to wzór sprowadza

się do

n !
n !

, a to niezależnie od wartości n wyniesie 1. Podobnie, jeśli k jest równe n, to wzór ponow-

nie sprowadza się do

n !
n !

, czyli do jedności. Korzystając z definicji silni można przepisać wzór ogól-

ny w następujący sposób:



n
k



=

n !

k !⋅n−k !

=

n⋅n−1!

k⋅ k −1!⋅n−k  !

=

n
k

⋅



n−1!



k −1!⋅n−k !

Napiszmy poniżej wzór dla wartości n-1 i k-1:



n−1
k −1



=



n−1!



k −1!⋅ n−1−k −1!

=



n−1!



k −1 !⋅ n−1−k 1!

=



n−1!



k −1!⋅n−k !

Porównując wzory (patrz: strzałka) można zauważyć, że:



n
k



=

n
k

⋅



n−1
k −1



Zbierając wszystkie wzory w jedną deklarację otrzymujemy „ładną”, rekurencyjną deklarację

funkcji.



n
k



=

{

1 gdy k =0

1 gdy k =n

n

k

⋅



n−1
k −1



gdy k ≠0 i k≠n

W powyższym wzorze „zgubiła się” funkcja silnia. To pierwszy sukces rekurencji w tym przypad-

ku, gdyż korzystanie z dokładnych wartości funkcji silnia ograniczało jej argument do liczby 20. Drugi

sukces polega na tym, że obliczanie wartości funkcji Symbol Newtona na podstawie pierwotnej defi -

nicji wymagało wykonania n+k+(n-k)+2=2n+2 mnożeń (w tym jedno dzielenie). Definicja rekurencyjna

pozwala ograniczyć liczbę mnożeń (i dzieleń) do 2k. Przy k bliskich n zysk nie jest wielki, jednak

można zastosować pewną tożsamość, a mianowicie:



n
k



≡



n

n−k



która powoduje, że n-k jest bliższe zeru. Tożsamość ta pozwala zredukować dolny argument do war-

tości mniejszych niż n/2, zatem zmniejsza liczbę mnożeń i dzieleń do wartości mniejszej niż n. Wyni -

ka stąd, że korzystanie z rekurencji skróci czas obliczeń o więcej niż połowę, ponadto umożliwi obli -

czenia dla argumentów większych niż 20. Biorąc powyższe pod uwagę napiszemy ostateczny wzór:



n
k



=

{

1 gdy k=0

1 gdy k =n

n

k

⋅



n−1
k −1



gdy k ≠0 i k ≠n i 2k ≤n



n

n−k



gdy k ≠0 i k ≠n i 2kn

Pierwsze dwa warunki można sprawdzać łącznie, gdyż funkcja zwraca tą samą wartość. Pe-

wien problem stanowi ułamek w trzecim wierszu definicji. Polega on na tym, że Symbol Newtona

z zasady jest liczbą całkowitą, a dzielenie w ogólności daje liczbę rzeczywistą. Będzie ona oczywi-

ście pozbawiona części ułamkowej, jednak kompilator będzie proponował zastosowanie funkcji kon-

wersji. Jednak pamiętając o tym, że wynik funkcji jest całkowity, można problem obejść stosując ope -

rator dzielenia całkowitego „\”, który daje wynik całkowity. Przy tym, ponieważ obliczenie wartości

funkcji musi nastąpić, to należy wywołanie funkcji ustawić jako pierwsze w wyrażeniu:

Return SymbolNewtona(n - 1, k - 1) * n \ k

W kolejnym ćwiczeniu należy zdefiniować funkcję w oparciu wzór:



n
k



=

{

1 gdy k=0

1 gdy k =n

n

k

⋅



n−1
k −1



gdy k ≠0 i k ≠n i 2k ≤n



n

n−k



gdy k ≠0 i k ≠n i 2kn

Ćwiczenie 77
Utworzyć nowy projekt aplikacji konsolowej i zdefiniować w części deklaracyjnej modułu
rekurencyjną funkcję SymbolNewtona typu Integer o dwóch parametrach n, k typu
Integer przekazywanych przez wartość realizującą wzór podany przed treścią ćwiczenia.
Zaprogramować wyświetlenie wartości funkcji dla n zmieniających się od 0 do 14 i k
zmieniających się od 0 do n.

Efekt działania aplikacji (zastosowano funkcję RSet) może być taki, jak na rysunku (jest to, tzw.

trójkąt Pascal’a):

Nie zawsze rekurencja pozwala osiągnąć zmniejszenie czasu pracy funkcji, a w niektórych

przypadkach powoduje nawet efekt odwrotny. Przykładem jest ciąg Fibbonacciego zdefiniowany

w następujący sposób:

F

n

=

{

1 gdy n=0
1 gdy n=1

F

n−2



F

n−1

gdy n1

Sprawdzenie działania rekurencyjnej deklaracji tego ciągu pozostawia się ćwiczącym do samo-

dzielnego wykonania. Ciekawym doświadczeniem będzie próba wyświetlenia pierwszych 50 wyrazów

ciągu (ustalić typ funkcji na Int64). Z pewnością (od wartości n większych niż 30) da się zaobserwo -

wać znaczny wzrost czasu obliczania kolejnych wartości.

Również procedury można programować rekurencyjnie. Rozważmy następujący przykład. Pro-

gram losuje liczbę z przedziału <1, 100> i dalsze jego działanie polega na kilkukrotnym sprawdzeniu

czy liczba podana przez użytkownika jest równa wylosowanej. Liczba prób może być ustalana jako

poziom trudności zadania i powinna być parametrem procedury. Również liczba wylosowana przez

program powinna być przekazana do procedury jako parametr.

Jakie działania powinna wykonywać potencjalna procedura realizująca sprawdzenie. Z pewno-

ścią powinna pobrać liczbę typowaną przez użytkownika. Mogą wystąpić trzy przypadki:

Liczba podana przez użytkownika jest równa liczbie wylosowanej przez program. Procedura

powinna powiadomić o tym użytkownika i zakończyć pracę (Exit Sub).

Rysunek 30: Projekt_077 w działaniu.

Liczba podana przez użytkownika jest za mała. Procedura powinna powiadomić o tym użyt-

kownika.

Liczba podana przez użytkownika jest za duża. Procedura powinna powiadomić o tym użyt-

kownika.

Dwa ostatnie przypadki nie kończą procedury, ale kończą próbę podjętą przez użytkownika, na-

leży to uwzględnić zmniejszając o jeden liczbę pozostałych prób. Dalszym działaniem powinno być

sprawdzenie, czy użytkownikowi pozostały jeszcze próby. Mogą wystąpić dwa przypadki:

Liczba pozostałych prób wynosi zero. Procedura powinna powiadomić o tym użytkownika i za-

kończyć pracę.

Pozostały jeszcze próby. Należy wykonać kolejne sprawdzenie. Procedura powinna wywołać

samą siebie, przekazując wylosowaną liczbę oraz liczbę pozostałych prób.

Kolejne ćwiczenie polegać będzie na stworzeniu rekurencyjnej procedury sprawdzającej i wyko -

rzystanie jej w programie.

Ćwiczenie 78
Utworzyć nowy projekt aplikacji konsolowej. Zdefiniować w części deklaracyjnej modułu
procedurę Sprawdź, o dwóch parametrach typu Integer przekazywanych przez wartość
(wylosowana liczba, liczba prób), realizującą opisany wcześniej schemat działania. W
programie zainicjować generator liczb losowych, zaprogramować losowanie liczby z
zakresu <1, 100> i uruchomić procedurę z parametrami: wartość wylosowanej liczby i 7.

Efekt działania aplikacji może być taki, jak na rysunku:

Rysunek 31: Projekt_078 w działaniu - sukces użytkownika.

lub taki jak na kolejnym rysunku:

Rysunek 32: Projekt_078 w działaniu - porażka użytkownika.