Funkcje

Kiedy ktoś mówi o C++ to ma na myśli przede wszystkim obiekty. Jednak
obiekty bazują, na funkcjach, które wykonują niezbędne do działania obiektu
operacje.

Każdy program w C++ posiada przynajmniej jedną funkcję, main () . Kiedy
uruchamia się program to funkcja main () jest automatycznie uruchamiana.
Może ona wywoływać inne funkcje, które z kolei mogą wywołać jeszcze inne.

Funkcja jest podprogramem, który może modyfikować dane i zwracać

wartość.

Każda funkcja ma swoją nazwę, a wywołanie funkcji polega na wpisaniu jej
nazwy w programie. W momencie napotkania wywołania funkcji program
przechodzi do wykonania kodu funkcji. Kiedy funkcja się kończy, to program
wraca do miejsca jej wywołania (do następnej instrukcji).

Ilustracja tego procesu

return;

Funkcja
4

Main()
{
Instrukcja;
Funkcja1 () ;
Instrukcja ;
Funkcja2 () ;
Instrukcja ;
Funkcja4 () ;
}

return;

Funkcja
1

return;

Funkcja
3

Instrukcja;
Funkcja3();

return;

Funkcja
2

Deklarowanie funkcji (prototypy)

Deklaracja funkcji określa jej nazwę, typ zwracanej wartości i listę
parametrów.

Standardowe funkcje dostarczone razem z kompilatorem posiadają już swoje
prototypy. Wystarczy dołączyć za pomocą #include odpowiedni plik
nagłówkowy (.H)
Prototyp funkcji to typ wartości zwracanej przez tę funkcję, nazwa i lista
parametrów. Prototyp kończy się znakiem średnika.
Lista

parametrów

to

wyszczególnienie

wszystkich

parametrów

przekazywanych do funkcji oddzielonych przecinkami.

unsigned short int PoliczPole ( int nDlugosc, int nSzerokosc);

typ zwracanej
wartości

nazw
a

parame
try

średn
ik

nazwa
parametru

typ
parametru

Przykład: „Elementy prototypu”

Żadna funkcja nie może być wywołana przez inną bez uprzedniego
zadeklarowania.

Deklaracja funkcji nazywana jest prototypem.

Definicja obejmuje treść funkcji.

Prototyp, pod względem typu wartości zwracanej, nazwy i typów parametrów,
musi zgadzać się z definicją funkcji.

Jeśli wystąpią różnice, to kompilator, przy próbie kompilacji,
zasygnalizuje błąd.

Przykład: long

Pole

( int , int );

Ten prototyp deklaruje funkcję

Pole ()

zwracającą wartość typu long i

posiadającą dwa parametry typu int. Mimo że taka deklaracja jest całkowicie
prawidłowa, to dla poprawienia przejrzystości zalecane jest podawanie w
prototypie również nazw parametrów. Deklaracja z nazwami parametrów
będzie wyglądać następująco:

long

Pole

( int nDlugosc, int nSzerokosc

) ;

Zauważmy, że wszystkie funkcje mają określony typ zwracanej wartości.

Prototyp funkcji mówi kompilatorowi o nazwie funkcji, wartości zwracanej i
parametrach.

typ_zwracany

nazwa_funkcji

( [

typ

[

nazwa_parametru

]]….)

;

składnia:

Porównajcie prototyp z definicją
funkcji.
Zwróćcie uwagę, że typ wartości
zwracanej,

nazwa

i

typy

parametrów są identyczne.
Gdyby były jakiekolwiek różnice to
kompilator wygenerowałby błąd.

Praktycznie jedyna wymagana
różnica polega na tym, ze
prototyp kończy się średnikiem
i nie zawiera treści funkcji.

Zwróćcie także uwagę na to, że
nazwy parametrów w prototypie to
nDlugosc i nSzerokosc, a nazwa
parametrów w definicji to d i s. Jak
widać,

nazwy

parametrów

w

prototypie nie są używane, służą
one jedynie jako informacja dla
programisty.

Definiowanie funkcji

Definicja funkcji składa się z nagłówka i treści funkcji. Nagłówek wygląda tak,
jak prototyp, jednak musi posiadać nazwy parametrów i nie może być
zakończony średnikiem.
Treści funkcji to zbiór instrukcji ograniczony klamrami.

unsigned short int ZnajdzPole ( int nDługosc, int
nSzerokosc )

{

// instrukcje

return ( nDlugosc*nSzerokosc ) ;

}

Klamra
zamykająca

Klamra
otwierająca

słowo
kluczowe

zwracana
wartość

typ zwracanej
wartości

nazw
a

parametry

Definicja mówi kompilatorowi co dana funkcja robi i jak działa.

typ_zwracany

nazwa_funkcji

( [

typ

[

nazwa_parametru

]]…. )

{

instrukcje;

}

Składnia:

Jeżeli funkcja zwraca jakąś wartość, to przed wyjściem z funkcji należy użyć
instrukcji return. Instrukcja ta może zostać użyta w każdym miejscu treści
funkcji.
Dla każdej funkcji określany jest typ wartości zwracanej. Jeśli nie podamy
typu, to automatycznie zostanie przypisany typ całkowity – int. Jeśli funkcja
nie zwraca żadnej wartości, to typem zwracanym będzie void.
Przykłady prototypów funkcji:

long Pole (long lDlugosc, long lSzerokosc);

Zwraca long,

ma dwa parametry

void WypiszTekst(int nNumerTekstu);

Zwraca void,

ma jeden parametr

int PobierzOpcje ();

Zwraca int,

brak parametrów

SpecFunk () ;

Zwraca int,

brak parametrów

Przykłady poprawnych definicji funkcji:

void WypiszTekst( int nNumerTekstu )
{
if ( nNumerTekstu == 0)
{
cout << "Czesc.\n";
}
if ( nNumerTekstu == 1)
{
cout << "Do widzenia. \n";
}
if ( nNumerTekstu > 1)
{
cout << "Jestem troche zaklopotany. \n";
}
}

long Pole ( long d, long s )
{
return d*s;
}

Zmienne lokalne

Zmienne można nie tylko przekazywać do funkcji. Można je również
deklarować wewnątrz funkcji. Wykorzystuje się w tym celu tzw. zmienne
lokalne. Zmienne te są widoczne tylko wewnątrz funkcji, w której są
zadeklarowane. Kiedy funkcja się kończy, zmienne przestają być dostępne.
Zmienne lokalne definiuje się tak samo jak wszystkie inne. Parametry
przekazywane do funkcji również są traktowane jako zmienne lokalne i można
je wykorzystywać tak, jakby były wewnątrz tej funkcji zadeklarowane.

Wartość

przekazywana

jako

parametr, fTempFer, również
jest tylko lokalną kopią zmiennej
przekazywaną z funkcji main ().

Deklarowana

jest

zmienna

lokalna fTempCel. Ta zmienna
istnieje tylko wewnątrz funkcji
Konwertuj ().

Zwróćmy uwagę, że nie jest to ta
sama zmienna co fTempCel.

Każda zmienna ma swój zasięg,
który mówi jak długo zmienna
jest dostępna i gdzie można z niej
korzystać.

Zmienne

zadeklarowane w osobnym bloku
widoczne są tylko wewnątrz niego
i giną wraz z końcem bloku.

Zmienne globalne

Zmienne zadeklarowane poza wszystkimi funkcjami mają globalny zasięg i
widoczne są wewnątrz wszystkich funkcji, łącznie z main (). Gmatwają one
bardzo program.

W profesjonalnie napisanych programach, są bardzo rzadko
spotkane.

Argumenty funkcji

Argumenty funkcji nie muszą być tego samego typu. Nie ma żadnych
przeciwwskazań, żeby argumentami funkcji były np.: jedna zmienna typu int,
dwie typu float i jedna typu char.
Każde poprawne wyrażenie może być argumentem funkcji. Mam tu na myśli
również stałe, wyrażenia matematyczne i logiczne oraz inne funkcje
zwracające wartość.

Funkcje jako parametry innych funkcji

Mimo że można używać funkcji zwracających wartości jako parametry do
innych funkcji, to prowadzi ono do zbędnego komplikowania kodu.

Przykład:

Załóżmy, że mamy funkcje RazyDwa (), RazyTrzy (), Kwadrat () i Szescian () ,
z których każda zwraca wartość. Można napisać:

lOdp = ( RazyDwa( RazyTrzy( Kwadrat( Szescian( lWartosc )))));

Ta instrukcja pobiera zmienną lWartosc, przekazuje ją jako argument do
funkcji Szescian (), zwracana wartość przekazywana jest z kolei od funkcji
Kwadrat(), której wynik przekazywany jest do funkcji RazyTrzy () w
rezultacie której operuje funkcja RazyDwa () . Wynik tego podwajania,
potrajania i potęgowania podstawiany jest do zmiennej lOdp.

Trudno na pierwszy rzut okna powiedzieć co ta instrukcja robi (czy wartość
była podnoszona do sześcianu zanim była podwojona czy nie?).
Również w momencie uzyskania wyniku niezgodnego z oczekiwaniami trudno
będzie znaleźć miejsce popełnienia błędu.

Alternatywnym rozwiązaniem jest przypisanie każdego kroku do osobnych
zmiennych:

unsigned long lWartosc = 2 ;

unsigned long lPotega3 = Szescian( lWartosc );// lPotenga3 =
8

unsigned long lPotega2 = Kwadrat( lPotega3 ); // lPotenga2 =
64

unsigned long lPrzez3 = RazyTrzy( lPotega2 );// lPrzez3 =
192

unsigned long lPrzez2 = RazyDwa( lPrzez3 ); // lPrzez2 =
384

Teraz każda pośrednia wartość może zostać przeanalizowana. Jasna jest
również kolejność wykonywania operacji.

Parametry są zmiennymi lokalnymi

Argumenty przekazywane do funkcji są w niej lokalne. Zmiana ich wartości
jest również lokalna i nie jest widoczna w funkcji wywołującej. Nazywamy to
przekazywaniem przez wartość, co oznacza, że w funkcji tworzona jest
lokalna kopia każdego argumentu przekazywanego do tej funkcji. Takie kopie
są traktowane tak, jak lokalne zmienne.

Ten program, w funkcji main() ,
inicjalizuje

dwie

zmienne

i

przekazuje je do funkcji Zamien(),
która teoretycznie je zamienia.

Jak

widać,

zmienne

zostały

przekazane do funkcji tylko przez
wartość. Zostały stworzone ich
lokalne kopie, i na tych kopiach
były

wykonywane

wszelkie

operacje. Były to lokalne zmienne
funkcji Zamien(). Zamiana została
dokonana tylko na kopiach i nie
miała żadnego wpływu na wartości
zmiennych w funkcji main().

Jednak po przetestowaniu wyniku w
funkcji main() okazuje się, że nic
się nie zmieniło!

Zwracanie wartości

Funkcje mogą zwracać albo jakąś wartość albo void. void to informacja dla
kompilatora, że funkcja nie będzie zwracać wartości. Żeby zwrócić wartość z
funkcji, należy użyć słowa kluczowego return, a następnie podać wartość,
która ma zostać zwrócona. Równie dobrze może być to wyrażenie zwracające
wartość.

Przykład:

return 5 ;

return ( x > 5 ) ;

return (MojaFunkcja() );

Po napotkaniu słowa kluczowego return wartość wymieniona po return jest
zwracana jako wartość funkcji, a program wraca do funkcji wywołującej.
Krótko mówiąc, instrukcja return, kończy wykonywanie danej funkcji.

Wartość zwrócona będzie równa zero
jeżeli x będzie nie większe niż 5, w
przeciwnym wypadku będzie równa
1. To co jest zwracane to wartość
wyrażenia, 0 (fałsz) lub 1 (prawda), a
nie wartość zmiennej x.

W jednej funkcji można wielokrotnie wykorzystywać instrukcję return.
Wykonanie instrukcji return powoduje zakończenie funkcji.

Funkcja Denominator() sprawdza, czy podana
liczba

nie

jest

większa

od

stałej

GRANICAGORNA

. Jeżeli nie, to funkcja zwraca

jej

wartość

pomnożoną

przez

stałą

DEWALUACJA

. Jeżeli jednak liczba jest większa

od 1000, to funkcja zwraca stałą

ERROR

jako

wartość błędną.

Instrukcja nigdy nie zostanie wykonana,
ponieważ niezależnie od wartości parametru
(większy od 1000 czy nie) funkcja zawsze wróci
albo albo .

Dobry kompilator zasygnalizuje, że ta

instrukcja

nigdy nie zostanie osiągnięta w trakcie
wykonywania programu. Niektóre kompilatory
zwrócą nawet komunikat błędu. Można tę linię
programu wykomentować.

Parametry domyślne

Do każdego zadeklarowanego w prototypie i definicji funkcji parametru,
funkcja wywołująca musi pobrać wartość zgodną z zadeklarowanym typem.
Przykład:
Jeżeli funkcję zadeklarowaną w następujący sposób:

long Funkcja ( int ) ;

to trzeba przekazywać do niej wartość całkowitą. Jeżeli definicja jest
niezgodna z prototypem, lub jeżeli wartość przekazywana nie będzie
całkowita to kompilator zasygnalizuje błąd.

Od tej reguły jest jeden

wyjątek

. Jeżeli w prototypie zadeklarujemy domyślną wartość dla parametru,

to gdy nie określimy danego argumentu, zostanie mu przypisana
automatycznie wartość domyślna. Odpowiednia deklaracja powinna wyglądać
następująco:

long Funkcja ( int x = 10 ) ;

Definicja funkcji nie zmienia się. Nagłówek definicji nadal będzie miał postać:

long Funkcja ( int x )

Teraz, gdy wywoła się funkcję bez określenia wartości argumentu to
kompilator automatycznie nada mu wartość 10. Nazwa parametru z
wartością domyślną nie musi być taka sama jak w nagłówku definicji, wartość
domyślna jest przypisywana na podstawie pozycji w liście parametrów, a nie
według nazwy.

Wartości domyślne można nadawać kilku parametrom funkcji. Jest tu jednak
pewne ograniczenie, jeżeli parametr nie ma określonej wartości domyślnej, to
żaden z poprzedzających go parametrów, również nie może posiadać
wartości domyślnej.

Jeżeli prototyp funkcji wygląda w następujący sposób:

long Funkcja ( int nParam1, int nParam2, int nParam3 ) ;

Przykład:

to parametrowi nParam2 można przypisać wartość domyślną wtedy i tylko
wtedy gdy przypisze się również wartość domyślną do nParam3. Podobnie,
gdy chce się przypisać wartość domyślną do nParam1 to trzeba uwzględnić
parametry nParam2 i nParam3 i również nadać im wartości domyślne.

Deklaracja funkcji ObjProstopadłościanu()
jako funkcję mającą trzy parametry. Dla dwóch
ostatnich są zadane wartości domyślne.

Jeżeli nie poda się nSzerokosci i nWysokosci
to program wykorzysta podane wartości: 10 i
3.

Zdeklarowane i zainicjalizowane zmienne
przekazywane są do funkcji
ObjProstopadlościanu().

Wywołujemy

funkcję

ObjProstopadloscianu(), lecz tym razem bez
parametru nWysokosc. Program wykorzystuje
wartość domyślną (3).

Trzecie

wywołanie

funkcji

ObjProstopadloscianu() Tym razem podany
jest

tylko

jeden

parametr

nDlugosc.

Pozostałym

parametrom

nadawane

są,

wartości domyślne.

Przeciążanie funkcji

C++ pozwala na stworzenie więcej niż jednej funkcji o tej samej nazwie.
Możliwość ta określana jest jako przeciążanie funkcji. Funkcje takie
muszą różnić się listą parametrów, typami parametrów lub ich liczbą.

Przykład:

int FunkcjaNew ( int, int ) ;

int FunkcjaNew ( long, long ) ;

int FunkcjaNew ( long ) ;

FunkcjaNew () jest przeciążona z użyciem trzech rożnych list parametrów.
Dwie pierwsze różnią się typem parametrów, trzecia ma inną ich liczbę.

W przypadku przeciążanych funkcji, typ wartości zwracanej może być
inny lub taki sam. Nie można przeciążać funkcji opierając się jedynie na
typie wartości zwracanej. Trzeba wykorzystać różne listy parametrów.

Przeciążanie funkcji określane jest również mianem

polimorfizmu

funkcji

.

Polimorfizm pozwala na przeciążanie funkcji za pomocą różnych ich treści.
Zmieniając liczbę lub typ parametrów, można nadać funkcjom te same
nazwy. W momencie wywołania, parametry będą decydować, która z funkcji
zostanie wykonana.

Załóżmy, że potrzebujemy funkcję podwajającą dowolną podaną wartość.
Chcielibyśmy mieć możliwość podania zmiennej typu int, long, float i
double.

Przykład:

Bez

przeciążania

funkcji

musiałoby się napisać cztery
funkcje o różnych nazwach:

int PodInt ( int ) ;

long PodLong ( long ) ;

float PodFloat ( float ) ;

doube PodDouble ( double ) ;

Natomiast

z

użyciem

przeciążenia

można

użyć

następującej deklaracji:

int Pod ( int ) ;

long Pod ( long ) ;

float Pod ( float ) ;

double Pod ( double ) ;

Funkcje wewnętrzne (inline)

Gdy definiuje się funkcję, kompilator tworzy w pamięci jeden zestaw
instrukcji. W momencie wywołania funkcji, program przechodzi do wykonania
tych instrukcji. Gdy funkcja kończy swoje działanie, program wraca do
następnej instrukcji po wywołaniu.

Jeżeli funkcja jest zadeklarowana ze słowem kluczowym inline, to
kompilator nie tworzy prawdziwej funkcji. Kopiuje natomiast jej kod w
każde miejsce wywołania. Nie jest wykonywany żaden skok. Wygląda to
tak, jakby fizycznie wpisać treść funkcji zamiast ją wywoływać.

gdy funkcję wywołuje się 10 razy

program tyle samo razy "skoczy" do instrukcji danej

funkcji.

w pamięci istnieje tylko jedna kopia funkcji, (a nie

10).

Prędkość
wykonywania
programu
zwiększa się gdy
unikniemy skoków
do funkcji.

Kiedy zatem stosować funkcje inline?

Wtedy gdy ma się małą funkcję (dwie, trzy linie), to można pomyśleć o

zamienieniu jej na wewnętrzną.

Jeżeli wywoła się taką funkcję dziesięciokrotnie to treść funkcji zostanie
skopiowana w każde z dziesięciu miejsc wywołania. Niewielki wzrost
wydajności może okazać się nieopłacalny w stosunku do wzrostu rozmiaru
kodu wynikowego.

Funkcje inline kosztują (pamięć).

Deklaracja

wygląda

jak

zwykły

prototyp, jedyna różnica polega na
użyciu słowa kluczowego inline. Taka
deklaracja funkcji powoduje, że w
tych miejscach:

nLiczba = 2 * nLiczba ;

nLiczba = 2 * nLiczba ;

nLiczba = 2 * nLiczba ;

Przed

wykonaniem

programu,

kompilator

umieszcza instrukcje funkcji
w kodzie. Oszczędza się w
ten

sposób

na

liczbie

skoków wewnątrz kodu, lecz
traci

na

rozmiarze

programu.

Bliższe spojrzenie na działanie funkcji

Wywołując funkcję, program przechodzi do wykonania instrukcji danej funkcji
i przekazuje parametry. Kiedy funkcja się kończy, zwracana jest wartość
(ewentualnie void) i program wraca do miejsca, z którego funkcja została
wywołana.



Jak to zadanie jest zorganizowane?

 Skąd program wie, dokąd ma przejść?

 Gdzie są przechowywane zmienne przekazywane do funkcji?

 Co się dzieje ze zmiennymi deklarowanymi wewnątrz funkcji?

 W jaki sposób jest przekazywana wartość zwracane przez funkcję?

 Skąd program wie, dokąd ma wrócić po wykonaniu funkcji?

Stos

Kiedy program rozpoczyna działanie, to kompilator tworzy stos.

Stos to specjalny obszar pamięci (struktura danych) służąca do
przechowywania danych wymaganych przez wszystkie funkcje w
programie. Określenie stos wynika z działania tej struktury, wartość,
która została położona na stos jako ostatnia zostanie zdjęta jako
pierwsza (LIFO ang. Last-in first-out).

Lepiej jest wyobrażać sobie stos jako odpowiedni ciąg komórek pamięci
ustawiony "do góry nogami". Szczyt jest tam gdzie wskazuje wskaźnik stosu.

100

101

102

103

104

105

106

107

108

109

110

80

50

37

Stos

Zmienna

nMojaKasa

nTwojaKasa

poza stosem

na stosie

102

Wskaźnik
stosu

Każda komórka stosu ma swój
adres. Jeden z tych adresów jest
przechowywany

w

rejestrze

stosu. Wszystko poniżej tego
adresu, nazywanego szczytem
stosu, jest traktowane jako
położone na stosie. Wszystko
powyżej jest poza stosem.

100

101

102

103

104

105

106

107

108

109

110

80

50

37

Stos

Zmienna

nMojaKasa

nTwojaKasa

poza stosem

na stosie

108

Wskaźnik
stosu

Kiedy wartość jest odkładana na stos, to jest umieszczana w komórce
powyżej wskaźnika stosu. Wskaźnik stosu jest przesuwany na tą komórkę.
Kiedy wartość jest zdejmowana, to faktycznie zmieniany jest tylko wskaźnik
stosu.

Stos i funkcje

Kiedy program wywołuje funkcję to tworzy dla niej ramkę stosu. Ramka stosu
to obszar na stosie, przeznaczony dla danej funkcji. Jest to bardzo ogólne i
rożnie wykonywane na rożnych komputerach. Można jednak wyróżnić kilka
podstawowych kroków:

Umieść na stosie adres powrotny. Kiedy funkcja się skończy, to

program wróci do tego adresu.

Zrób na stosie miejsca dla zadeklarowanej wartości zwracanej

przez funkcję.

Umieść na stosie argumenty funkcji.

Przejdź do wykonywania funkcji.

Umieść na stosie zmienne lokalne funkcji według ich definicji.