Wprowadzenie




Funkcje




Zawartość podrozdziału:




Zwracanie rezultatu przez funkcję
Stos
Przesyłanie argumentów przez wartość
Przesyłanie argumentów przez referencję
Kiedy deklaracja nie jest konieczna
Argumenty domniemane
Nienazwany argument






Jedną z najsympatyczniejszych cech nowoczesnych języków programowania jest to, że można w nich posługiwać się podprogramami. Podprogram to jakby mały program we właściwym programie. Dzięki podprogramom możemy jakby definiować swoje własne "instrukcje" :

Jeśli napiszemy sobie podprogram realizujący operację liczenia pola koła na podstawie zadanego promienia - to tak, jakbyśmy język programowania wyposażyli w nową instrukcję umiejącą właśnie to obliczać. Od tej pory - ile razy w programie potrzebujemy obliczyć pole koła - wywołujemy nasz podprogram, a jest to tak proste, jak napisanie zwykłej instrukcji.

Podprogram, który jako rezultat zwraca jakąś wartość, nazywamy po prostu funkcją. W języku C++ wszystkie podprogramy nazywane są funkcjami. Funkcję wywołuje się przez podanie jej nazwy i umieszczonych w nawiasie argumentów.


Oto przykład programu zawierającego funkcję:
Nazywa się ona kukułka, a jej zadaniem jest kukać żądaną ilość razy. To, ile razy - jest parametrem wysyłanym do funkcji.

#include <iostream.h>
int kukulka(int ile); // 1
/**************************************************/
main()
{
int m = 20 ;
cout << "Zaczynamy" << endl ;

m = kukułka(5) ; // 2
cout << "\nNa koniec m = " << m ; // 3
}
/**************************************************/
int kukułka(int ile) // 4
{ // 5

int i ;
for(i = 0 ; i < ile ; i++)
{
cout << "Ku-ku ! ";
}
return 77 ; // 6
} // 7

foliogram nr 19


Wykonanie tego programu objawi się na ekranie jako:

Zaczynamy
Ku-ku ! Ku-ku ! Ku-ku ! Ku-ku ! Ku-ku !
Na koniec m = 77


Przyjrzyjmy się temu programowi

Funkcja ma swoją nazwę, która ją identyfikuje. Jak pamiętamy z poprzednich
rozdziałów, wszelkie nazwy - przed pierwszym odwołaniem się do nich -
muszą zostać zadeklarowane. Wymagana jest więc także deklaracja nazwy
funkcji. W tym miejscu programu widzimy deklarację nazwy funkcji. Deklaracja
ta mówi kompilatorowi:
kukułka jest funkcją wywoływaną z argumentem typu int, a zwracającą jako
rezultat wartość typu int.
Powtórzmy:

Przed odwołaniem się do nazwy wymagana jest jej deklaracja. Deklaracja, ale niekoniecznie od razu definicja. Sama funkcja może być zdefiniowana później, nawet w zupełnie innym pliku. Zdefiniować funkcję, to znaczy po prostu napisać jej treść.

Definicja funkcji znajduje się w (4)
Wywołanie funkcji to po prostu napisanie jej nazwy łącznie z nawiasem, gdzie znajduje się argument przesyłany do funkcji. Ponieważ spodziewamy się, że funkcja zwróci jakąś wartość, dlatego widzimy przypisanie tej wartości do zmiennej m.
Na dowód, że funkcja rzeczywiście zwróciła jakąś wartość, i że nastąpiło przypisanie tej wartości do obiektu m - wypisujemy go w tym miejscu na ekran.
Tu się zaczyna definicja funkcji. Definicja ta zawiera tzw. ciało funkcji, czyli wszystkie instrukcje wykonywane w ramach tej funkcji. Dwie klamry (5) i (7) określają ten obszar ciała funkcji, czyli po prostu jej treść.
Jest to moment, gdy funkcja kończy swoją pracę i wraca do miejsca skąd została wywołana [return = ang. powrót]. Obok słowa return widzimy wartość, którą zdecydowaliśmy zwrócić jako rezultat wykonania tej funkcji.



Zatrzymajmy się trochę przy deklaracjach funkcji. Oto kilka przykładów:

float kwadrat (int bok);
void fun (int stopien; char znaczek; int nachylenie);
int przypadek(void);
char znak_x ();
void pin(...);


Zauważ, że na końcu każdej z przedstawionych deklaracji jest średnik. Przeczytajmy teraz te deklaracje.

kwadrat jest funkcją (wywoływaną z jednym argumentem typu int), która w rezultacie zwraca wartość typu float.
fun jest funkcją (wywoływaną z 3 argumentami typu : int, char, int), która nie zwraca żadnej wartości. Słowo void [ang. - próżny] służy tu właśnie do wyraźnego zaznaczenia tego faktu.
Po takiej deklaracji - jeśli kompilator zobaczy, że przez zapomnienie próbujemy uzyskać z tej funkcji jakąś wartość - ostrzeże nas, sygnalizując błąd.
przypadek to funkcja, która wywoływana jest bez żadnego argumentu, a która zwraca wartość typu int.
znak_x to funkcja, która wywoływana jest bez żadnych argumentów, a w rezultacie zwraca wartość typu char.
pin jest funkcją, którą wywołuje się z bliżej nieokreślonymi (teraz jeszcze) argumentami, a która nie zwraca żadnej wartości.




Uwaga dla programistów C:
Jest tu zmiana w stosunku do klasycznego C.
Pusty nawias w deklaracji funkcji np. f () ; oznacza

w języku C - dowolną liczbę argumentów czyli to samo co f(...)

w języku C++ - brak jakichkolwiek argumentów, czyli to samo co f(void)



Jeśli masz przyzwyczajenia z klasycznego C, to zapamiętaj, że odtąd


 Deklaracja f(); - oznacza f(void);



Nazwy argumentów umieszczone w nawiasach przedstawionych deklaracji są nieistotne dla kompilatora i można je pominąć. Powtarzam: nazwy, a nie typy argumentów.


Dlatego deklarację funkcji

void fun(int stopień, char znaczek, int nachylenie);

można napisać także jako

void fun(int, char, int);


To dlatego, że w deklaracji powiadamiamy kompilator o liczbie i typie argumentów. Ich nazwy nie są w tym momencie istotne. (To będzie ważne w definicji).


Masz więc dwa sposoby deklarowania funkcji. Namawiam Cię jednak do stosowania pierwszego sposobu - tego z nazwami argumentów. Przemawiają za nim dwa względy praktyczne:

jest on czytelniejszy dla programisty, przypomina bowiem lepiej czym zajmuje się funkcja,
łatwiej taką deklarację napisać. Mimo, że jest dłuższa. Po prostu pracując w edytorze przenosi się we właściwe miejsce (u nas - na górę programu) pierwszą linijkę definicji funkcji i stawia się na końcu tej linijki średnik.



Zauważ, że w naszym ostatnim programie definicję funkcji oddzieliłem za pomocą linijki komentarza składającą się z rzędu gwiazdek. Radzę Ci robić podobnie. Bardzo to polepszy czytelność Twoich programów. Jeśli masz plik, w którym mieści się trzydzieści definicji funkcji, to łatwiej się w nim orientować. Już na pierwszy rzut oka widać, gdzie się jedna funkcja kończy, a zaczyna druga.