Prednáška 4

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ávratovovej 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.
}

Príklad č. 1: Súčet čísel od a po b

Nasledujúca funkcia dostane dvojicu celých čísel a, b a vráti súčet všetkých celých čísel od a po b vrátane.

/* Funkcia, ktora spocita 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;
}

Program využívajúci túto funkciu môže vyzerať napríklad takto:

#include <iostream>
using namespace std;

/* Funkcia, ktora spocita 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;
}

int main() {
    int a, b;
    
    cout << "Zadaj dvojicu celych cisel: ";
    cin >> a >> b;
    
    cout << "Sucet celych cisel od " << a << " po " << b << ": ";
    cout << sum(a, b) << endl;
}

Príklad č. 2: Vypisovanie čísel od a po b

Predpokladajme teraz, že potrebujeme napísať funkciu printNumbers, ktorá čísla od a po b iba vypíše na výstup. Takáto funkcia teda nebude vracať žiadnu zmysluplnú hodnotu – jej návratový typ bude void. V ostatnom sa táto funkcia od funkcie z predošlého príkladu nebude príliš odlišovať.

/* Funkcia, ktora vypise cisla a, (a+1), ..., (b-1), b */
void printNumbers(int a, int b) {
    cout << "Cisla od " << a << " po " << b << ":";    
    for (int i = a; i <= b; i++) {
        cout << " " << i;
    }    
    cout << endl;
}

Kompletný program využívajúci túto funkciu:

#include <iostream>
using namespace std;

/* Funkcia, ktora vypise cisla a, (a+1), ..., (b-1), b */
void printNumbers(int a, int b) {
    cout << "Cisla od " << a << " po " << b << ":";    
    for (int i = a; i <= b; i++) {
        cout << " " << i;
    }    
    cout << endl;
}

int main(void) {
    int a, b;
    
    cout << "Zadaj dvojicu celych cisel: ";
    cin >> a >> b;
    
    printNumbers(a, b);

    return 0;
}

Príklad č. 3: Sčítanie a súčasné vypisovanie čísel a od b

Funkcie z predchádzajúcich dvoch príkladov je možné spojiť do jednej, ktorá tieto čísla vypíše a súčasne na výstupe vráti ich súčet:

/* Funkcia, ktora scita a vypise cisla a, (a+1), ..., (b-1), b */
int sumAndPrint(int a, int b) {
    int result = 0;
    cout << "Cisla od " << a << " po " << b << ":";    
    for (int i = a; i <= b; i++) {
        result += i;
        cout << " " << i;
    }    
    cout << endl;
    return result;
}

Kompletný program využívajúci túto funkciu:

#include <iostream>
using namespace std;

/* Funkcia, ktora scita a vypise cisla a, (a+1), ..., (b-1), b */
int sumAndPrint(int a, int b) {
    int result = 0;
    cout << "Cisla od " << a << " po " << b << ":";    
    for (int i = a; i <= b; i++) {
        result += i;
        cout << " " << i;
    }    
    cout << endl;
    return result;
}

int main(void) {
    int a, b;
    
    cout << "Zadaj dvojicu celych cisel: ";
    cin >> a >> b;
    
    int sum = sumAndPrint(a, b);
    cout << "Sucet cisel je: " << sum << endl;
    
    sumAndPrint(a,b); // Vystupnu hodnotu funkcie mozeme aj odignorovat.

    return 0;
}

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.

Jednotlivé členy tejto postupnosti sa nazývajú Fibonacciho čísla. Prvých niekoľko členov Fibonacciho postupnosti je

Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 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, \ldots}

a n-té Fibonacciho číslo F(n) možno vypočítať pomocou nasledujúceho rekurentného vzťahu:

• 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.

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;
    }
}

Kompletný program využívajúci túto funkciu:

#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(void) {
    int n;
    cout << "Zadaj n: ";
    cin >> n;
    
    cout << "F(" << n << ") = " << fibonacci(n) << endl;

    return 0;
}

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(void) {
    cout << f() << endl; // Vypise 1.
    return 0;
}

• Funkcia s návratovým typom void môže tiež obsahovať príkaz return, avšak bez návratovej hodnoty za ním (t.j. bezprostredne nasledovaný bodkočiarkou). V takom prípade slúži iba na ukončenie vykonávania funkcie podobne, ako v nasledujúcom príklade, ktorý je ukážkou vyslovene zlého programátorského štýlu:

#include <iostream>
using namespace std;

void f(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(void) {
    int n;
    cin >> n;
    f(n);
    return 0;
}

• Napríklad minimum z dvoch čísel môžeme vypočítať dvoma rôznymi spôsobmi (ak z nejakého dôvodu nechceme použiť niektorú zo štandardných funkcií slúžiacich k tomuto účelu):

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”). Neskoršie volanie takýchto funkcií potom môže viesť k zákerným chybám. Definíciu funkcie s typom iným ako void, ktorá môže skončiť inak ako príkazom return, teda budeme považovať za chybu (a to aj v prípade „istoty”, že sa výstupné hodnoty tejto funkcie nebudú nikde používať; vtedy je totiž správnou voľbou návratový typ void).

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 tejto funkcie, ak je táto 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 samozrejme 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é.

Príklad č. 1: Program s globálnou premennou x

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(void) {
    x = 10;
    int y = 20;
        
    f();                            // Vypise 10 10.  
    cout << x << " " << y << endl;  // Vypise 10 20.
    
    return 0;
}

Príklad č. 2: Prekrývanie globálnych premenných lokálnymi

Nasledujúci program demonštruje mechanizmus prekrývania globálnych premenných lokálnymi.

#include <iostream>
using namespace std;

/* Z nasledujucej funkcie globalnu premennu n pouzivat nemozeme, lebo je 
 * v programe definovana az neskor: */
void f1(void) {
    // n = 1; 
}

int n = -1;    // Premennu n inicializujeme na hodnotu -1.

void f2(void) {
    n = 2;     // Nastavi hodnotu globalnej premennej n na 2.
}

void f3(void) {
    int n;     // Lokalna premenna prekryje globalnu. 
    n = 3;     // Meni len lokalnu premennu bez vplyvu na globalnu premennu n.
}

int main(void) {
    cout << n << endl; // Vypise -1.
    f2();      
    cout << n << endl; // Vypise 2.
    f3();      
    cout << n << endl; // Vypise 2.
    
    return 0;
}

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(void) {
    int n = 1;
    f(n);               // Vypise 2.
    cout << n << endl;  // Vypise 1.
    
    return 0;
}

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 samotnej 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(void) {
    int n = 1;
    f(n);               // Vypise 2.
    cout << n << endl;  // Vypise 2.
    
    return 0;
}

Príklad č. 1: 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(void) {
    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; 
        
    return 0;
}

Príklad č. 2: Funkcia swap

Typickým príkladom na použitie odovzdávania 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(void) {
    int x, y;
    cin >> x >> y;
    
    swap(x, y);
    
    cout << "x = " << x << ", y = " << y << endl; 
        
    return 0;
}

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 je potrebné korektne sa vysporiadať aj so vstupmi, ktoré tieto podmienky nespĺňajú (aj keď túto skutočnosť budeme často zámerne ignorovať). 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(void) {
    int n;
    cout << "Zadaj kladne cele cislo: ";
    cin >> n;
        
    cout << "Sucet delitelov " << n << ": " << sumOfDivisors(n) << "." << endl;
        
    return 0;
}

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. V našom prípade zrejme potrebujeme vyjadriť neúspešné ukončenie programu – ako parameter funkcie exit teda použijeme 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(void) {
    int n;
    cout << "Zadaj kladne cele cislo: ";
    cin >> n;
        
    cout << "Sucet delitelov " << n << ": " << sumOfDivisors(n) << "." << endl;
        
    return 0;
}

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(void) {
    int n;
    cout << "Zadaj kladne cele cislo: ";
    cin >> n;
        
    cout << "Sucet delitelov " << n << ": " << sumOfDivisors(n) << "." << endl;
        
    return 0;
}

Ú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. Elegantnejším riešením je preto napríklad nasledovné: súčet deliteľov už nebudeme vracať ako výstupnú hodnotu, ale budeme ho ukladať do parametra odovzdávaného referenciou. Výstupom funkcie bude namiesto toho 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(void) {
    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;
    }
        
    return 0;
}

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). Napríklad

void f1(void) {
    f2();
}

void f2(void) {
    cout << "Hello, World!" << endl;
}

typicky neskompiluje, kým

void f2(void) {
    cout << "Hello, World!" << endl;
}

void f1(void) {
    f2();
}

je v poriadku. 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).
• 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é určitou hodnotou, ktoré sa zadajú pri volaní funkcie.
• Parametre odovzdávané referenciou (&) sú len novým menom pre inú premennú.