Programovanie (2) v Jave
1-INF-166, letný semester 2023/24
Prednáška 4: Rozdiel medzi revíziami
Riadok 323: | Riadok 323: | ||
} | } | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | * Napríklad minimum z dvoch čísel môžeme vypočítať dvoma rôznymi spôsobmi | + | * Napríklad minimum z dvoch čísel môžeme vypočítať dvoma rôznymi spôsobmi: |
<syntaxhighlight lang="C++"> | <syntaxhighlight lang="C++"> | ||
int minimum1(int a, int b) { | int minimum1(int a, int b) { | ||
Riadok 343: | Riadok 343: | ||
} | } | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | * Funkcie s návratovým typom iným ako <tt>void</tt> je žiadúce písať tak, aby na ľubovoľnom vstupe ich vykonávanie vždy skončilo príkazom <tt>return</tt>. Ak totiž takáto funkcia skončí inak, než príkazom <tt>return</tt>, jej výstupná hodnota je nedefinovaná (použije sa „hocijaký nezmysel”) | + | * Funkcie s návratovým typom iným ako <tt>void</tt> je žiadúce písať tak, aby na ľubovoľnom vstupe ich vykonávanie vždy skončilo príkazom <tt>return</tt>. |
+ | ** Ak totiž takáto funkcia skončí inak, než príkazom <tt>return</tt>, jej výstupná hodnota je nedefinovaná (použije sa „hocijaký nezmysel”), čo môže viesť k zákerným chybám. | ||
− | + | Cvičenie: Nájdite hodnotu nasledujúcej funkcie pre ''n=6'' a ''n=7''. Viete stručne popísať, čo funkcia robí pre všeobecné ''n''? | |
<syntaxhighlight lang="C++"> | <syntaxhighlight lang="C++"> | ||
int zahada(int n) { | int zahada(int n) { | ||
Riadok 361: | Riadok 362: | ||
Premenné v C/C++ možno rozdeliť na ''globálne'' a ''lokálne'': | Premenné v C/C++ možno rozdeliť na ''globálne'' a ''lokálne'': | ||
* ''Globálne premenné'' možno používať vo všetkých funkciách, ktoré sú v programe definované za touto premennou. | * ''Globálne premenné'' možno používať vo všetkých funkciách, ktoré sú v programe definované za touto premennou. | ||
− | * ''Lokálne premenné'' sú definované vo vnútri funkcie a môžu sa používať iba v rámci nej (alebo iba v rámci niektorej časti | + | * ''Lokálne premenné'' sú definované vo vnútri funkcie a môžu sa používať iba v rámci nej (alebo iba v rámci niektorej časti funkcie, ak je premenná definovaná napríklad v tele cyklu a podobne). |
Platí navyše, že: | Platí navyše, že: | ||
− | * Viaceré funkcie môžu mať lokálne premenné s tým istým názvom – každá funkcia potom | + | * Viaceré funkcie môžu mať lokálne premenné s tým istým názvom – každá funkcia potom používa tú svoju. |
* Ak má lokálna premenná rovnaký názov ako nejaká globálna premenná, lokálna premenná ''prekryje'' globálnu – funkcia teda používa svoju lokálnu premennú (bližšia košeľa ako kabát). | * Ak má lokálna premenná rovnaký názov ako nejaká globálna premenná, lokálna premenná ''prekryje'' globálnu – funkcia teda používa svoju lokálnu premennú (bližšia košeľa ako kabát). | ||
Je silno odporúčané ''používať predovšetkým lokálne premenné''. Väčšie programy s globálnymi premennými môžu byť veľmi neprehľadné. | Je silno odporúčané ''používať predovšetkým lokálne premenné''. Väčšie programy s globálnymi premennými môžu byť veľmi neprehľadné. | ||
− | |||
− | |||
Nasledujúci program obsahuje globálnu premennú <tt>x</tt> a v každej funkcii lokálnu premennú s názvom <tt>y</tt>: | Nasledujúci program obsahuje globálnu premennú <tt>x</tt> a v každej funkcii lokálnu premennú s názvom <tt>y</tt>: | ||
Riadok 391: | Riadok 390: | ||
} | } | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | |||
− | |||
Nasledujúci program demonštruje mechanizmus prekrývania globálnych premenných lokálnymi. | Nasledujúci program demonštruje mechanizmus prekrývania globálnych premenných lokálnymi. | ||
Riadok 400: | Riadok 397: | ||
using namespace std; | using namespace std; | ||
− | /* | + | /* V nasledujucej funkcii nemozeme pouzit |
+ | * globalnu premennu n, lebo je | ||
* v programe definovana az neskor: */ | * v programe definovana az neskor: */ | ||
void f1(void) { | void f1(void) { | ||
Riadok 406: | Riadok 404: | ||
} | } | ||
− | + | // Globalnu premennu n inicializujeme na -1. | |
+ | int n = -1; | ||
void f2(void) { | void f2(void) { | ||
− | + | // Nastavi hodnotu globalnej premennej n na 2. | |
+ | n = 2; | ||
} | } | ||
void f3(void) { | void f3(void) { | ||
− | + | // Lokalna premenna prekryje globalnu. | |
− | n | + | int n; |
+ | // Meni len lokalnu premennu bez vplyvu na globalnu premennu n. | ||
+ | n = 3; | ||
} | } | ||
Riadok 441: | Riadok 443: | ||
sa parametru <tt>a</tt> priradí hodnota 1 a parametru <tt>b</tt> sa priradí hodnota 2. Tieto sa ďalej správajú ako lokálne premenné funkcie <tt>f</tt>. Možno ich teda meniť, ale táto zmena sa neprejaví na mieste, odkiaľ funkciu voláme. Tento mechanizmus nazývame ''odovzdávaním parametrov hodnotou''. | sa parametru <tt>a</tt> priradí hodnota 1 a parametru <tt>b</tt> sa priradí hodnota 2. Tieto sa ďalej správajú ako lokálne premenné funkcie <tt>f</tt>. Možno ich teda meniť, ale táto zmena sa neprejaví na mieste, odkiaľ funkciu voláme. Tento mechanizmus nazývame ''odovzdávaním parametrov hodnotou''. | ||
− | + | Príklad: | |
<syntaxhighlight lang="C++"> | <syntaxhighlight lang="C++"> | ||
#include <iostream> | #include <iostream> | ||
Riadok 462: | Riadok 464: | ||
V prípade, že pred názov niektorého parametra v hlavičke funkcie napíšeme <tt>&</tt>, parameter sa bude ''odovzdávať referenciou''. | V prípade, že pred názov niektorého parametra v hlavičke funkcie napíšeme <tt>&</tt>, parameter sa bude ''odovzdávať referenciou''. | ||
* Za takýto parameter možno pri volaní funkcie dosadiť iba premennú (kým pri odovzdávaní hodnotou môžeme použiť napríklad aj konštanty alebo iný výraz). | * Za takýto parameter možno pri volaní funkcie dosadiť iba premennú (kým pri odovzdávaní hodnotou môžeme použiť napríklad aj konštanty alebo iný výraz). | ||
− | * Namiesto | + | * Namiesto hodnoty sa funkcii pošle adresa premennej v pamäti (referencia). |
* Funkcia potom bude túto premennú používať pod novým názvom; jej prípadné zmeny sa prejavia aj na mieste, odkiaľ bola funkcia volaná. | * Funkcia potom bude túto premennú používať pod novým názvom; jej prípadné zmeny sa prejavia aj na mieste, odkiaľ bola funkcia volaná. | ||
− | + | Príklad: | |
− | |||
<syntaxhighlight lang="C++"> | <syntaxhighlight lang="C++"> | ||
#include <iostream> | #include <iostream> | ||
Riadok 483: | Riadok 484: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | === | + | Ďalej si ukážeme niekoľko použití odovzdávania parametrov referenciou. |
+ | |||
+ | === Viac ako jedna návratová hodnota === | ||
Odovzdávanie parametra referenciou používame napríklad vtedy, keď potrebujeme vrátiť viac ako jednu výstupnú hodnotu. | Odovzdávanie parametra referenciou používame napríklad vtedy, keď potrebujeme vrátiť viac ako jednu výstupnú hodnotu. | ||
+ | |||
Napríklad nasledujúca funkcia <tt>mid</tt> dostane súradnice dvoch bodov <tt>[x1,y1]</tt> a <tt>[x2,y2]</tt> a do parametrov <tt>[xm,ym]</tt>, ktoré sú odovzdané referenciou, uloží súradnice stredu úsečky spájajúcej body <tt>[x1,y1]</tt> a <tt>[x2,y2]</tt>. | Napríklad nasledujúca funkcia <tt>mid</tt> dostane súradnice dvoch bodov <tt>[x1,y1]</tt> a <tt>[x2,y2]</tt> a do parametrov <tt>[xm,ym]</tt>, ktoré sú odovzdané referenciou, uloží súradnice stredu úsečky spájajúcej body <tt>[x1,y1]</tt> a <tt>[x2,y2]</tt>. | ||
Riadok 492: | Riadok 496: | ||
using namespace std; | using namespace std; | ||
− | void mid(double x1, double y1, double x2, double y2, double &xm, double &ym) { | + | void mid(double x1, double y1, double x2, double y2, |
+ | double &xm, double &ym) { | ||
xm = (x1 + x2) / 2; | xm = (x1 + x2) / 2; | ||
ym = (y1 + y2) / 2; | ym = (y1 + y2) / 2; | ||
Riadok 507: | Riadok 512: | ||
double Mx, My; | double Mx, My; | ||
mid(Ax, Ay, Bx, By, Mx, My); | mid(Ax, Ay, Bx, By, Mx, My); | ||
− | cout << "Stred usecky AB je [" << Mx << ", " << My << "]." << endl; | + | cout << "Stred usecky AB je [" |
+ | << Mx << ", " << My << "]." << endl; | ||
} | } | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | === | + | === Funkcia <tt>swap</tt> === |
− | Typickým príkladom | + | Typickým príkladom použitia odovzdávania parametrov referenciou je funkcia <tt>swap</tt>, ktorá vymení hodnoty dvoch premenných, ktoré dostane ako parametre. |
<syntaxhighlight lang="C++"> | <syntaxhighlight lang="C++"> | ||
Riadok 539: | Riadok 545: | ||
== Ošetrovanie chybných vstupov == | == Ošetrovanie chybných vstupov == | ||
− | Občas môže nastať potreba, aby parametre funkcie spĺňali určité podmienky. V takom prípade | + | Občas môže nastať potreba, aby parametre funkcie spĺňali určité podmienky. V takom prípade môže byť potrebné korektne sa vysporiadať aj so vstupmi, ktoré tieto podmienky nespĺňajú. Ukážeme si teraz zopár možných prístupov k tomuto problému. |
=== Funkcia neošetrujúca chybné vstupy === | === Funkcia neošetrujúca chybné vstupy === | ||
Riadok 572: | Riadok 578: | ||
=== Použitie funkcie <tt>exit</tt> === | === Použitie funkcie <tt>exit</tt> === | ||
− | V prípade použitia nekorektného vstupu napríklad môžeme celý program ihneď ukončiť funkciou <tt>exit</tt> (treba <tt>#include <cstdlib></tt>). Parametrom tejto funkcie je návratová hodnota celého programu, ktorá typicky udáva, či program skončil korektne alebo nie. | + | V prípade použitia nekorektného vstupu napríklad môžeme celý program ihneď ukončiť funkciou <tt>exit</tt> (treba <tt>#include <cstdlib></tt>). |
+ | * Parametrom tejto funkcie je návratová hodnota celého programu, ktorá typicky udáva, či program skončil korektne alebo nie. | ||
+ | * Na vyjadrenie neúspešného ukončenia programu použijeme preddefinovanú konštantu <tt>EXIT_FAILURE</tt>. | ||
<syntaxhighlight lang="C++"> | <syntaxhighlight lang="C++"> | ||
Riadok 632: | Riadok 640: | ||
=== Úspech výpočtu ako výstupná hodnota === | === Úspech výpočtu ako výstupná hodnota === | ||
− | Často je ale neprípustné v prípade jediného volania funkcie s nekorektnými vstupmi ukončiť celý program. | + | Často je ale neprípustné v prípade jediného volania funkcie s nekorektnými vstupmi ukončiť celý program. Chceli by sme teda vrátiť dve hodnoty: samotný súčet deliteľov a indikátor, či boli argumenty zadané správne. |
+ | * Napríklad súčet deliteľov môžeme ukladať do parametra odovzdávaného referenciou. | ||
+ | * Výstupom funkcie bude booleovská hodnota, ktorá bude <tt>true</tt> práve vtedy, keď výpočet funkcie prebehol správne (t.j. keď boli zadané správne argumenty). Túto výstupnú hodnotu je potom možné použiť pri volaní funkcie ako známku toho, že hodnota v parametre predanom referenciou je zmysluplná. | ||
<syntaxhighlight lang="C++"> | <syntaxhighlight lang="C++"> | ||
Riadok 667: | Riadok 677: | ||
== Programy s viacerými funkciami == | == Programy s viacerými funkciami == | ||
− | V programe možno volať iba funkcie, ktoré už predtým boli niekde definované alebo aspoň deklarované (tento pojem si ozrejmíme o chvíľu). | + | V programe možno volať iba funkcie, ktoré už predtým boli niekde definované alebo aspoň deklarované (tento pojem si ozrejmíme o chvíľu). |
+ | |||
+ | Tento program typicky neskompiluje (vo vnútri f1 ešte nepozná f2) | ||
<syntaxhighlight lang="C++"> | <syntaxhighlight lang="C++"> | ||
void f1(void) { | void f1(void) { | ||
Riadok 677: | Riadok 689: | ||
} | } | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | ||
+ | Tento program je v poriadku: | ||
<syntaxhighlight lang="C++"> | <syntaxhighlight lang="C++"> | ||
void f2(void) { | void f2(void) { | ||
Riadok 687: | Riadok 700: | ||
} | } | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | ||
+ | Program tiež skompiluje v prípade, že každú funkciu pred jej volaním aspoň ''zadeklarujeme'' – t.j. uvedieme jej hlavičku bez definície jej tela – a samotnú definíciu funkcie uvedieme až neskôr. V poriadku je teda napríklad aj nasledujúci program: | ||
<syntaxhighlight lang="C++"> | <syntaxhighlight lang="C++"> | ||
void f2(void); | void f2(void); | ||
Riadok 705: | Riadok 719: | ||
* V programe ju nemožno volať – jediné jej volanie je automatické (začína sa ním beh programu). | * V programe ju nemožno volať – jediné jej volanie je automatické (začína sa ním beh programu). | ||
* Výstupná hodnota funkcie <tt>main</tt> sa interpretuje ako „spôsob ukončenia” programu (napríklad 0 pre korektné ukončenie, iné hodnoty pre chyby). | * Výstupná hodnota funkcie <tt>main</tt> sa interpretuje ako „spôsob ukončenia” programu (napríklad 0 pre korektné ukončenie, iné hodnoty pre chyby). | ||
+ | ** Funkciu <tt>main</tt> môžeme teda ukončit napríklad príkazom <tt>return 0</tt>. | ||
* Funkcia <tt>main</tt> môže mať aj určité presne špecifikované parametre (viac o tom neskôr). | * Funkcia <tt>main</tt> môže mať aj určité presne špecifikované parametre (viac o tom neskôr). | ||
Riadok 712: | Riadok 727: | ||
* V tele funkcie sú samotné príkazy. Vypočítanú hodnotu vrátime príkazom <tt>return</tt>. | * V tele funkcie sú samotné príkazy. Vypočítanú hodnotu vrátime príkazom <tt>return</tt>. | ||
* Lokálne premenné sú viditeľné len vo funkcii, ktorá ich definuje, globálne vo všetkých funkciách. | * Lokálne premenné sú viditeľné len vo funkcii, ktorá ich definuje, globálne vo všetkých funkciách. | ||
− | * Parametre odovzdávané hodnotou sú lokálne premenné inicializované | + | * Parametre odovzdávané hodnotou sú lokálne premenné inicializované hodnotami, ktoré sa zadajú pri volaní funkcie. |
* Parametre odovzdávané referenciou (<tt>&</tt>) sú len novým menom pre inú premennú. | * Parametre odovzdávané referenciou (<tt>&</tt>) sú len novým menom pre inú premennú. | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− |
Verzia zo dňa a času 22:11, 29. september 2020
Obsah
Oznamy
Čo nás čaké v najbližších dňoch
- V piatok doplnkové cvičenia, osobne alebo cez MS Teams
- Príďte, ak potrebujete pomôcť s riešením úloh
- Môžete sa len na krátko pripojiť, aby ste si vyskúšali spojenie cez MS Teams
- Od budúceho týždňa dištančná výučba, podľa bežného rozvrhu
- Prednášky aj cvičenia cez MS Teams
- Návod na použitie MS Teams
- V pondelok 5. októbra bude časť prednášky teoretické cvičenie, na ktorom bude krátky test v MS Teams
- Test bude z prvých troch prednášok
- Môžete používať ľubovoľné papierové materiály aj stránku predmetu (poznámky z prednášok), zakázané sú iné webstránky, použitie editorov, kompilátorov, programátorských prostredí, komunikovanie s inými osobami
- Pozor, nebude veľa času hľadať niečo v prednáškach, lepšie je spraviť si prehľadný ťahák
- Test sa hodnotí v rámci bodov za cvičenia, študenti, ktorí napísali test pre pokročilých sa ho nemusia zúčastniť.
Funkcie
Funkcia je samostatný kus kódu (postupnosť príkazov) s určitým menom. Po zavolaní funkcie jej menom sa daná postupnosť príkazov vykoná.
- V iných programovacích jazykoch sa používajú aj podobné termíny ako procedúra, metóda, či podprogram.
- Funkcia vo všeobecnosti dostane niekoľko (aj nula) vstupných argumentov, ktoré môže pri svojom behu používať.
- Funkcia tiež môže vrátiť výstupnú hodnotu.
- Ide teda o veľmi podobný koncept ako funkcie v matematike (ako napríklad sin(x)):
- Oboje si možno predstaviť ako „krabičku”, ktorá na základe niekoľkých vstupných hodnôt vráti nejakú výstupnú hodnotu.
- Funkcie v C/C++ ale môžu okrem vracania výstupných hodnôt vykonávať ľubovoľný kód, teda napríklad aj niečo vypisovať na konzolu a podobne.
Funkcie sú užitočné z viacerých dôvodov:
- Umožňujú vytvoriť „skratku” pre často používané časti kódu, ktoré tak nie je nutné zakaždým písať nanovo.
- Umožňujú používanie kusov kódu vytvorených iným programátorom. Napríklad sme sa už stretli s funkciou sqrt, ktorá vráti druhú odmocninu svojho vstupu.
- Funkcie umožňujú oddeliť očakávanú funkcionalitu od jej reálnej implementácie. Napríklad pri volaní sqrt nás implementácia tejto funkcie typicky nezaujíma. Stačí vedieť, že pre každé číslo na vstupe táto funkcia vráti jeho odmocninu.
Obvod trojuholníka bez použitia funkcií
Užitočnosť funkcií ilustrujeme na príklade. Chceme napísať program, ktorý od používateľa načíta súradnice vrcholov trojuholníka ABC a na výstup vypíše obvod tohto trojuholníka. Beh takéhoto programu teda môže vyzerať napríklad takto:
Zadaj suradnice vrcholu A: 0 0 Zadaj suradnice vrcholu B: 3 0 Zadaj suradnice vrcholu C: 0 4 Obvod trojuholnika ABC: 12
Obvod spočítame ako súčet dĺžok jednotlivých strán, v programe teda trikrát opakujeme výpočet dĺžky strany:
#include <iostream>
#include <cmath>
using namespace std;
int main() {
double Ax, Ay, Bx, By, Cx, Cy;
cout << "Zadaj suradnice vrcholu A: ";
cin >> Ax >> Ay;
cout << "Zadaj suradnice vrcholu B: ";
cin >> Bx >> By;
cout << "Zadaj suradnice vrcholu C: ";
cin >> Cx >> Cy;
/* Spocitaj dlzky jednotlivych stran: */
double a = sqrt((Bx - Cx) * (Bx - Cx) + (By - Cy) * (By - Cy));
double b = sqrt((Ax - Cx) * (Ax - Cx) + (Ay - Cy) * (Ay - Cy));
double c = sqrt((Ax - Bx) * (Ax - Bx) + (Ay - By) * (Ay - By));
cout << "Obvod trojuholnika ABC: " << a + b + c;
}
Opakované písanie toho istého vzorca na výpočet dĺžky strany je prácne; navyše pri ňom ľahko spravíme chybu. V nasledujúcom programe ho teda nahradíme funkciou.
Obvod trojuholníka s použitím funkcie
Videli sme teda, že na výpočet obvodu trojuholníka sa nám môže zísť funkcia počítajúca vzdialenosť medzi dvoma bodmi v rovine (dĺžka jednej strany trojuholníka je vzdialenosťou jeho koncových bodov). Tá môže v C/C++ vyzerať napríklad takto:
double dist(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
Týmto sme zadefinovali funkciu s názvom dist so štyrmi vstupnými argumentmi x1, y1, x2, y2 typu double, reprezentujúcimi súradnice dvojice bodov v rovine. Pred samotný názov funkcie sme zadali návratový typ funkcie, ktorým je double – táto funkcia teda bude vracať na výstupe reálne čísla. Nakoniec sme zadefinovali samotné telo funkcie, tentokrát pozostávajúce z jediného špeciálneho príkazu return, ktorým funkcia vracia svoju výstupnú hodnotu.
Kompletný program na výpočet obvodu trojuholníka môže s použitím funkcie dist vyzerať napríklad takto:
#include <iostream>
#include <cmath>
using namespace std;
/* Definicia funkcie dist: */
double dist(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
int main() {
double Ax, Ay, Bx, By, Cx, Cy;
cout << "Zadaj suradnice vrcholu A: ";
cin >> Ax >> Ay;
cout << "Zadaj suradnice vrcholu B: ";
cin >> Bx >> By;
cout << "Zadaj suradnice vrcholu C: ";
cin >> Cx >> Cy;
// Spocitaj dlzky jednotlivych stran:
// Volanie funkcie dist s argumentmi Bx, By, Cx, Cy
double a = dist(Bx, By, Cx, Cy);
// Volanie funkcie dist s argumentmi Ax, Ay, Cx, Cy
double b = dist(Ax, Ay, Cx, Cy);
// Volanie funkcie dist s argumentmi Ax, Ay, Bx, By
double c = dist(Ax, Ay, Bx, By);
cout << "Obvod trojuholnika ABC: " << a + b + c;
}
Telo funkcie nemusí pozostávať iba z jediného príkazu. Napríklad ešte jednoduchšie by sme funkciu dist mohli napísať takto:
double dist(double x1, double y1,
double x2, double y2) {
double dx = x1 - x2;
double dy = y1 - y2;
return sqrt(dx * dx + dy * dy);
}
Cvičenie:
- V Pascale existuje funkcia sqr, ktorá na vstupe berie reálne číslo x a výstupom je toto číslo umocnené na druhú. Naprogramujte túto funkciu v C/C++ a použite ju na zjednodušenie funkcie dist.
- Mohli by sme použiť aj pow(x,2) (treba #include <cmath>), ale môže byť jednoduchšie zrátať x*x.
Definícia funkcie
Definícia funkcie pozostáva z nasledujúcich častí:
- Typ návratovej hodnoty funkcie. Funkcia z úvodného príkladu napríklad vracia vzdialenosť bodov v rovine, teda hodnotu typu double. Podobne môžeme písať funkcie vracajúce iné návratové typy, napríklad int. Funkcie, ktoré nemajú vracať žiadnu hodnotu majú špeciálny návratový typ void – ide typicky o funkcie, ktoré len vykonajú určitú činnosť, napríklad vypísanie textu na konzolu a podobne.
- Identifikátor funkcie. Funkciu môžeme (v rámci určitých medzí) pomenovať prakticky ľubovoľne, rovnako ako pri premenných. Vhodné je však použiť názov, ktorý vystihuje úlohu danej funkcie (napríklad dist od angl. distance).
- Zoznam vstupných parametrov funkcie. V zátvorkách za názvom funkcie je zoznam typov a identifikátorov vstupných argumentov, ktoré funkcia očakáva. V úvodnom príklade funkcia očakáva súradnice dvoch bodov v rovine, teda štyri hodnoty typu double. Ak funkcia neočakáva žiaden vstupný argument, môžeme do zátvoriek napísať void alebo nechať zoznam argumentov prázdny.
- Telo funkcie. Do zložených zátvoriek za definíciou funkcie píšeme postupnosť príkazov, ktoré má funkcia vykonať.
- Príkaz return. Vracia návratovú hodnotu funkcie.
typ_navratovej_hodnoty identifikator_funkcie(zoznam_vstupnych_argumentov) {
telo_funkcie // Môže obsahovať príkazy return.
}
Súčet čísel od a po b
Ukážeme si tri verzie funkcie, ktorá dostane dvojicu celých čísel a, b a spočíta súčet všetkých celých čísel od a po b vrátane.
- Prvá verzia tento súčet vráti ako návratovú hodnotu.
- Druhá verzia súčet vypíše, vrátane sčitovaných čísel, jej návratový typ bude void.
- Tretia verzia súčet aj vypíše aj vráti.
/* Funkcia, ktora vrati sucet a + (a+1) + ... + (b-1) + b */
int sum(int a, int b) {
int result = 0;
for (int i = a; i <= b; i++) {
result += i;
}
return result;
}
/* Funkcia, ktora vypise cisla a, (a+1), ..., b a ich sucet */
void printNumbers(int a, int b) {
int result = 0;
for (int i = a; i <= b; i++) {
if (i > a) {
cout << " + ";
}
cout << i;
result += i;
}
cout << " = " << result << endl;
}
/* Funkcia, ktora vypise cisla a, (a+1), ..., b a ich sucet
* a tento sucet aj vrati. */
int sumAndPrint(int a, int b) {
int result = 0;
for (int i = a; i <= b; i++) {
if (i > a) {
cout << " + ";
}
cout << i;
result += i;
}
cout << " = " << result << endl;
return result;
}
Program využívajúci tieto funkcie môže vyzerať napríklad takto:
#include <iostream>
using namespace std;
// sem pridu definicie funkcii sum, printNUmbers, sumAndPrint
// uvedene vyssie
int main() {
int a, b;
cout << "Zadaj dvojicu celych cisel: ";
cin >> a >> b;
cout << "Test funkcie sum" << endl;
cout << "Sucet celych cisel od " << a << " po " << b << ": ";
// zavolame funkciu a vysledok priamo vypiseme
cout << sum(a, b) << endl;
// vysledok funkcie mozeme ulozit do premennej
// a pouzit neskor:
int sucet = sum(a, b);
cout << "Druha mocnina suctu cisel je: " << sucet * sucet << endl;
cout << endl << "Test funkcie printNumbers" << endl;
// tato funkcia nema vysledok, nic neukladame
printNumbers(a, b);
cout << endl << "Test funkcie sumAndPrint" << endl;
// dalsia funkcia vypise aj vrati hodnotu
int sucet2 = sumAndPrint(a, b);
cout << "Druha mocnina suctu cisel je: " << sucet2 * sucet2 << endl;
// vystupnu hodnotu funkcie mozeme aj odignorovat
sumAndPrint(a,b);
}
Príklad č. 4: Fibonacciho čísla
Fibonacciho postupnosť je postupnosť čísel taká, že:
- Nultý člen je 0.
- Prvý člen je 1.
- Každý ďalší člen postupnosti je daný súčtom dvoch predchádzajúcich.
Prvých niekoľko členov Fibonacciho postupnosti je
- 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, ...
Formálnejšiu definíciu n-tého Fibonacciho čísla F(n) môžeme zapísať ako rekurentný vzťah:
- F(0) = 0,
- F(1) = 1,
- Pre všetky prirodzené čísla n ≥ 2: F(n) = F(n - 1) + F(n - 2).
Napíšeme teraz funkciu fibonacci, ktorá pre dané n vypočíta n-té Fibonnaciho číslo F(n) a poožijeme ju v programe.
#include <iostream>
using namespace std;
int fibonacci(int n) {
if (n == 0) {
return 0;
} else if (n == 1) {
return 1;
} else {
int F_posledne = 1;
int F_predposledne = 0;
for (int i = 2; i <= n; i++) {
int F_n = F_posledne + F_predposledne;
F_predposledne = F_posledne;
F_posledne = F_n;
}
return F_posledne;
}
}
int main() {
int n;
cout << "Zadaj n: ";
cin >> n;
cout << "F(" << n << ") = " << fibonacci(n) << endl;
}
Príklad behu programu:
Zadaj n: 9 F(9) = 34
Cvičenie: Napíšte funkciu printFibonacci, ktorá vypíše prvých n Fibonacciho čísel.
- Akú bude mať táto funkcia hlavičku?
- Vyskúšajte dva spôsoby implementácie: volaním funkcie fibonacci pre rôzne hodnoty n a prepísaním tejto funkcie, aby sa hodnoty vypisovali priamo počas ich výpočtu. Ktorý spôsob bude rýchlejší pre veľké n a prečo?
Príkaz return
Pozrime sa teraz bližšie na špeciálny príkaz return:
- Po vykonaní príkazu return je funkcia okamžite zastavená a jej výstupná hodnota je výraz za slovom return.
- Funkcia môže obsahovať aj viacero volaní return. Akonáhle sa však jedno z nich vykoná, funkcia končí s danou návratovou hodnotou. Napríklad:
#include <iostream>
using namespace std;
int f(void) {
return 1;
return 2; // Nikdy sa nevykona.
return 3; // Nikdy sa nevykona.
}
int main() {
cout << f() << endl; // Vypise 1.
}
- Funkcia s návratovým typom void môže tiež obsahovať príkaz return, avšak bez návratovej hodnoty.
- V takom prípade return slúži iba na ukončenie vykonávania funkcie, väčšinou je lepšie prepísať inak
- Tu je ukážka, kde namiesto return by bolo lepšie použiť else:
#include <iostream>
using namespace std;
void akeCislo(int n) {
if (n >= 0) {
cout << "Cislo je nezaporne." << endl;
return;
}
cout << "Cislo je zaporne." << endl; // Vykona sa len v pripade n < 0.
}
int main() {
int n;
cin >> n;
akeCislo(n);
}
- Napríklad minimum z dvoch čísel môžeme vypočítať dvoma rôznymi spôsobmi:
int minimum1(int a, int b) {
int minval;
if (a < b) {
minval = a;
} else {
minval = b;
}
return minval;
}
int minimum2(int a, int b) {
if (a < b) {
return a;
} else {
return b;
}
}
- Funkcie s návratovým typom iným ako void je žiadúce písať tak, aby na ľubovoľnom vstupe ich vykonávanie vždy skončilo príkazom return.
- Ak totiž takáto funkcia skončí inak, než príkazom return, jej výstupná hodnota je nedefinovaná (použije sa „hocijaký nezmysel”), čo môže viesť k zákerným chybám.
Cvičenie: Nájdite hodnotu nasledujúcej funkcie pre n=6 a n=7. Viete stručne popísať, čo funkcia robí pre všeobecné n?
int zahada(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return i;
}
}
return n;
}
Lokálne a globálne premenné
Premenné v C/C++ možno rozdeliť na globálne a lokálne:
- Globálne premenné možno používať vo všetkých funkciách, ktoré sú v programe definované za touto premennou.
- Lokálne premenné sú definované vo vnútri funkcie a môžu sa používať iba v rámci nej (alebo iba v rámci niektorej časti funkcie, ak je premenná definovaná napríklad v tele cyklu a podobne).
Platí navyše, že:
- Viaceré funkcie môžu mať lokálne premenné s tým istým názvom – každá funkcia potom používa tú svoju.
- Ak má lokálna premenná rovnaký názov ako nejaká globálna premenná, lokálna premenná prekryje globálnu – funkcia teda používa svoju lokálnu premennú (bližšia košeľa ako kabát).
Je silno odporúčané používať predovšetkým lokálne premenné. Väčšie programy s globálnymi premennými môžu byť veľmi neprehľadné.
Nasledujúci program obsahuje globálnu premennú x a v každej funkcii lokálnu premennú s názvom y:
#include <iostream>
using namespace std;
int x;
void f(void) {
int y = 10;
cout << x << " " << y << endl;
}
int main() {
x = 10;
int y = 20;
f(); // Vypise 10 10.
cout << x << " " << y << endl; // Vypise 10 20.
}
Nasledujúci program demonštruje mechanizmus prekrývania globálnych premenných lokálnymi.
#include <iostream>
using namespace std;
/* V nasledujucej funkcii nemozeme pouzit
* globalnu premennu n, lebo je
* v programe definovana az neskor: */
void f1(void) {
// n = 1;
}
// Globalnu premennu n inicializujeme na -1.
int n = -1;
void f2(void) {
// Nastavi hodnotu globalnej premennej n na 2.
n = 2;
}
void f3(void) {
// Lokalna premenna prekryje globalnu.
int n;
// Meni len lokalnu premennu bez vplyvu na globalnu premennu n.
n = 3;
}
int main() {
cout << n << endl; // Vypise -1.
f2();
cout << n << endl; // Vypise 2.
f3();
cout << n << endl; // Vypise 2.
}
Parametre funkcií
Odovzdávanie parametrov hodnotou
Vstupné parametre funkcií sa správajú ako lokálne premenné danej funkcie. Pri volaní funkcie sa každému parametru priradí určitá hodnota. Uvažujme napríklad funkciu
void f(int a, int b) {
// ...
}
Pri volaní
f(1,2);
sa parametru a priradí hodnota 1 a parametru b sa priradí hodnota 2. Tieto sa ďalej správajú ako lokálne premenné funkcie f. Možno ich teda meniť, ale táto zmena sa neprejaví na mieste, odkiaľ funkciu voláme. Tento mechanizmus nazývame odovzdávaním parametrov hodnotou.
Príklad:
#include <iostream>
using namespace std;
void f(int n) {
n++;
cout << n << endl;
}
int main() {
int n = 1;
f(n); // Vypise 2.
cout << n << endl; // Vypise 1.
}
Odovzdávanie parametrov referenciou
V prípade, že pred názov niektorého parametra v hlavičke funkcie napíšeme &, parameter sa bude odovzdávať referenciou.
- Za takýto parameter možno pri volaní funkcie dosadiť iba premennú (kým pri odovzdávaní hodnotou môžeme použiť napríklad aj konštanty alebo iný výraz).
- Namiesto hodnoty sa funkcii pošle adresa premennej v pamäti (referencia).
- Funkcia potom bude túto premennú používať pod novým názvom; jej prípadné zmeny sa prejavia aj na mieste, odkiaľ bola funkcia volaná.
Príklad:
#include <iostream>
using namespace std;
void f(int &n) {
n++;
cout << n << endl;
}
int main() {
int n = 1;
f(n); // Vypise 2.
cout << n << endl; // Vypise 2.
}
Ďalej si ukážeme niekoľko použití odovzdávania parametrov referenciou.
Viac ako jedna návratová hodnota
Odovzdávanie parametra referenciou používame napríklad vtedy, keď potrebujeme vrátiť viac ako jednu výstupnú hodnotu.
Napríklad nasledujúca funkcia mid dostane súradnice dvoch bodov [x1,y1] a [x2,y2] a do parametrov [xm,ym], ktoré sú odovzdané referenciou, uloží súradnice stredu úsečky spájajúcej body [x1,y1] a [x2,y2].
#include <iostream>
using namespace std;
void mid(double x1, double y1, double x2, double y2,
double &xm, double &ym) {
xm = (x1 + x2) / 2;
ym = (y1 + y2) / 2;
}
int main() {
double Ax, Ay, Bx, By;
cout << "Zadaj suradnice bodu A: ";
cin >> Ax >> Ay;
cout << "Zadaj suradnice bodu B: ";
cin >> Bx >> By;
double Mx, My;
mid(Ax, Ay, Bx, By, Mx, My);
cout << "Stred usecky AB je ["
<< Mx << ", " << My << "]." << endl;
}
Funkcia swap
Typickým príkladom použitia odovzdávania parametrov referenciou je funkcia swap, ktorá vymení hodnoty dvoch premenných, ktoré dostane ako parametre.
#include <iostream>
using namespace std;
void swap(int &a, int &b) {
int tmp = a;
a = b;
b = tmp;
}
int main() {
int x, y;
cin >> x >> y;
swap(x, y);
cout << "x = " << x << ", y = " << y << endl;
}
Keby sme funkcii odovzdali parameter hodnotou – čiže by sme funkciu swap definovali s hlavičkou void swap(int a, int b); – vo funkcii main by sa premenné nevymenili.
Ošetrovanie chybných vstupov
Občas môže nastať potreba, aby parametre funkcie spĺňali určité podmienky. V takom prípade môže byť potrebné korektne sa vysporiadať aj so vstupmi, ktoré tieto podmienky nespĺňajú. Ukážeme si teraz zopár možných prístupov k tomuto problému.
Funkcia neošetrujúca chybné vstupy
Uvažujme napríklad nasledujúcu funkciu, ktorá počíta súčet všetkých deliteľov čísla n. Jej základným predpokladom je, že n je kladné celé číslo.
#include <iostream>
using namespace std;
int sumOfDivisors(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
sum += i;
}
}
return sum;
}
int main() {
int n;
cout << "Zadaj kladne cele cislo: ";
cin >> n;
cout << "Sucet delitelov " << n << ": " << sumOfDivisors(n) << "." << endl;
}
Ak však používateľ zadá na vstupe nejaké záporné číslo, funkcia vždy vráti nulu, čo nie je úplne v súlade s očakávaním. Jednou možnosťou by samozrejme bolo prerobiť funkciu tak, aby pracovala správne aj na záporných vstupoch. Sú však aj situácie, keď podobné riešenie nie je možné. Ukážeme si preto ďalšie spôsoby, ako sa s nekorektným vstupom vysporiadať.
Použitie funkcie exit
V prípade použitia nekorektného vstupu napríklad môžeme celý program ihneď ukončiť funkciou exit (treba #include <cstdlib>).
- Parametrom tejto funkcie je návratová hodnota celého programu, ktorá typicky udáva, či program skončil korektne alebo nie.
- Na vyjadrenie neúspešného ukončenia programu použijeme preddefinovanú konštantu EXIT_FAILURE.
#include <iostream>
#include <cstdlib>
using namespace std;
int sumOfDivisors(int n) {
if (n <= 0) {
exit(EXIT_FAILURE);
}
int sum = 0;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
sum += i;
}
}
return sum;
}
int main() {
int n;
cout << "Zadaj kladne cele cislo: ";
cin >> n;
cout << "Sucet delitelov " << n << ": " << sumOfDivisors(n) << "." << endl;
}
Použitie funkcie assert
Pohodlnejšou alternatívou je použitie funkcie assert (treba #include <cassert>). Táto funkcia umožňuje predpokladať platnosť nejakej podmienky – ak je táto podmienka splnená, program normálne pokračuje; v opačnom prípade sa program zastaví s chybovou hláškou. Argumentom funkcie assert môže byť ľubovoľná booleovská hodnota.
#include <iostream>
#include <cassert>
using namespace std;
int sumOfDivisors(int n) {
assert(n > 0);
int sum = 0;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
sum += i;
}
}
return sum;
}
int main() {
int n;
cout << "Zadaj kladne cele cislo: ";
cin >> n;
cout << "Sucet delitelov " << n << ": " << sumOfDivisors(n) << "." << endl;
}
Úspech výpočtu ako výstupná hodnota
Často je ale neprípustné v prípade jediného volania funkcie s nekorektnými vstupmi ukončiť celý program. Chceli by sme teda vrátiť dve hodnoty: samotný súčet deliteľov a indikátor, či boli argumenty zadané správne.
- Napríklad súčet deliteľov môžeme ukladať do parametra odovzdávaného referenciou.
- Výstupom funkcie bude booleovská hodnota, ktorá bude true práve vtedy, keď výpočet funkcie prebehol správne (t.j. keď boli zadané správne argumenty). Túto výstupnú hodnotu je potom možné použiť pri volaní funkcie ako známku toho, že hodnota v parametre predanom referenciou je zmysluplná.
#include <iostream>
using namespace std;
bool sumOfDivisors(int n, int &sum) {
if (n <= 0) {
return false;
} else {
sum = 0;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
sum += i;
}
}
return true;
}
}
int main() {
int n, sum;
cout << "Zadaj kladne cele cislo: ";
cin >> n;
if (sumOfDivisors(n, sum)) {
cout << "Sucet delitelov " << n << ": " << sum << "." << endl;
} else {
cout << "Zly vstup" << endl;
}
}
Programy s viacerými funkciami
V programe možno volať iba funkcie, ktoré už predtým boli niekde definované alebo aspoň deklarované (tento pojem si ozrejmíme o chvíľu).
Tento program typicky neskompiluje (vo vnútri f1 ešte nepozná f2)
void f1(void) {
f2();
}
void f2(void) {
cout << "Hello, World!" << endl;
}
Tento program je v poriadku:
void f2(void) {
cout << "Hello, World!" << endl;
}
void f1(void) {
f2();
}
Program tiež skompiluje v prípade, že každú funkciu pred jej volaním aspoň zadeklarujeme – t.j. uvedieme jej hlavičku bez definície jej tela – a samotnú definíciu funkcie uvedieme až neskôr. V poriadku je teda napríklad aj nasledujúci program:
void f2(void);
void f1(void) {
f2();
}
void f2(void) {
cout << "Hello, World!" << endl;
}
Funkcia main
Špeciálnou funkciou je v C/C++ funkcia main. Od ostatných funkcií sa odlišuje v nasledujúcom:
- V programe ju nemožno volať – jediné jej volanie je automatické (začína sa ním beh programu).
- Výstupná hodnota funkcie main sa interpretuje ako „spôsob ukončenia” programu (napríklad 0 pre korektné ukončenie, iné hodnoty pre chyby).
- Funkciu main môžeme teda ukončit napríklad príkazom return 0.
- Funkcia main môže mať aj určité presne špecifikované parametre (viac o tom neskôr).
Funkcie: zhrnutie
- Funkcie nám umožňujú rozbiť väčší program na menšie logické časti a tým ho sprehľadniť. Tiež nám umožňujú vyhnúť sa opakovaniu podobných kusov kódu.
- Hlavička funkcie obsahuje návratový typ (môže byť void), meno funkcie, typy a mená parametrov.
- V tele funkcie sú samotné príkazy. Vypočítanú hodnotu vrátime príkazom return.
- Lokálne premenné sú viditeľné len vo funkcii, ktorá ich definuje, globálne vo všetkých funkciách.
- Parametre odovzdávané hodnotou sú lokálne premenné inicializované hodnotami, ktoré sa zadajú pri volaní funkcie.
- Parametre odovzdávané referenciou (&) sú len novým menom pre inú premennú.