1
Príkazy jazyka C++
1. Úvod
Doposiaľ sme si povedali o tom, z akých stavebných jednotiek sa program v C++
skladá, aká je jeho základná štruktúra, boli opísané typy údajov, s ktorými môžeme pracovať, a naposledy aj operácie, ktoré s týmito údajmi môžeme vykonávať. Na to, aby sa
mohli začať písať trochu zmysluplnejšie programy ako tých pár jednoduchých účelových
príkladov, ešte niečo chýba. To niečo, ako ostatne vyplýva z názvu, sú to príkazy jazyka
C++. Ako sme si povedali v jednej z predchádzajúcich častí, program je postupnosť lexikálnych jednotiek. Takto podaná definícia sa bude veľmi páčiť kompilátoru, programátor
má však na svoj výtvor trochu iný pohľad. Dá sa povedať, že program je postupnosť príkazov. Do určitej miery je to pravda, ale o niečo presnejšia definícia hovorí, že program
v C++ je postupnosťou deklarácií. Príkaz, riadiaca štruktúra je teda určitý spôsob, ktorým
hovoríme počítaču, čo od neho chceme a delia sa na:

Výrazový príkaz,

Blok, zložený príkaz,

Príkazy vetvenia, podmienený príkaz a prepínač,

Príkazy cyklu,

Príkazy skoku,

Funkcie.
2. Výrazový príkaz
S týmto príkazom ste sa už veľakrát stretli, aj keď o tom možno vôbec neviete. Jeho
syntax je veľmi jednoduchá, je tvorený ľubovoľným výrazom, za ktorým nasleduje bodkočiarka ;. Výrazový príkaz teda vzniká pridaním znaku ";" za výraz. V nasledujúcom programe sú tri výrazové príkazy:
/* priklad výrazové prikazy */
void main(void)
{
int a,b;
a = 1;
/* prvy vyrazovy prikaz */
b += 1+3*a;
/* druhy vyrazovy prikaz */
printf("a=%d b=%d\n",a,b); /* treti vyrazovy prikaz */
}
3. Blok
Niekde sa možno stretnúť s pojmom príkazový blok alebo blokový príkaz. Blokový príkaz
vyzerá takto:
ľavá krútená zátvorka {
ľubovoľný (aj nulový) počet iných príkazov (ľubovoľného typu)
2
a nakoniec pravá krútená zátvorka }.
Takýto príkaz navonok vystupuje ako jediný, hoci vnútri je vlastne tvorený niekoľkými príkazmi. Použitie je všade tam, kde syntax jazyka C++ povoľuje jediný príkaz, potom sa musí v prípade, že potrebujeme vykonať viacero príkazov, použiť jeden blokový príkaz. Príklad úseku programu so zloženým príkazom:
double s = 3800.0;
{
double v, t = 12.58;
v = s / t;
printf(„v = %lg\n“, v);
}
s += 1218.0;
Za blokovým príkazom sa nepíše bodkočiarka. Ak ju tam dáme, vytvoríme dva príkazy – jeden zložený a hneď za ním jeden prázdny. V bloku je taktiež možné deklarovať
lokálne premenné, ktoré majú platnosť iba v rámci daného bloku. Z iných častí programu,
resp. blokov nie sú takéto premenné viditeľné. Blok, ktorý obsahuje iba príkazy bez deklarácií premenných, označujeme ako zložený príkaz. Pre zápis zložených, krútených zátvoriek platí nepísané pravidlo. Odsadenia zátvoriek od ľavého okraja by mali byť rovnaké
podľa stupňa blokového príkazu.
{ // začiatok bloku 1
blok1
{ // začiatok bloku2
blok2
} // koniec bloku2
{ // začiatok bloku3
blok3
} // koniec bloku3
} // koniec bloku1
4. Príkazy vetvenia
Do tejto skupiny patria dva príkazy: podmienený príkaz, ktorý sa zapisuje pomocou kľúčových slov if a else a príkaz prepínač a ten sa vyjadruje kľúčovým slovom switch. Tieto
príkazy sú neoddeliteľnou súčasťou každého programovacieho jazyka a teda CPP nevynímajúc. Podstatná časť algoritmov a teda aj z toho odvodených programov obsahuje časti, ktoré sa niekedy, ak je splnená určitá podmienka vykonávajú, ak podmienka nie je splnená táto časť programu sa nevykoná.
4.1. Podmienený príkaz if...else
Rozdeľuje, vetví program do dvoch smerov. Syntax príkazu zobrazujú nasledujúce konštrukcie:
if (podmienka)
príkaz;
3
podmienka predstavuje relačný alebo logický výraz, ktorého hodnota môže byť true - príkaz sa vykoná, ak podmienka je false príkaz sa nevykoná, bude ignorovaný a bude sa pokračovať nasledujúcim príkazom. Ak príkaz predstavuje viac jednoduchých príkazov je
potrebné použiť blok príkazov alebo zložený príkaz. Táto forma príkazu if predstavuje akúsi jednocestnú výhybku. Ukážka použitia hore spomínanej formy podmieneného príkazu
zobrazuje nasledujúci program:
#include <cstdlib>
#include <iostream>
// podmienený príkaz if 1. forma x sa zmeni na kladnu
int main()
{
int x;
printf("Zadaj hodnotu X: "); scanf("%i",&x);
printf("Zadana hodnota X = %i\n",x);
if (x < 0 ) x = abs(x);
// zmena x na kladnu hodnotu
printf("Zmenena hodnota na kladnu X = %i\n",x);
system("PAUSE");
return 0;
}
Program vyžaduje zadanie celého čísla, premenná x, ak je záporná tak sa jej hodnota
s použitím funkcie asb(x) zmení na kladnú. V ostatnom prípade ak x≥0 hodnota premennej x sa nezmení, to realizuje príkaz if.
Ďalšia forma zápisu príkazu používa kľúčové slovo else.
if (podmienka)
príkaz1;
else
príkaz2;
Druhá forma umožňuje výber z dvoch alternatív, z ktorých sa vykoná práve jedna. Pri vykonávaní tejto druhej formy sa opätovne vyhodnotí podmienka a v prípade, že jej hodnota
bude true, vykoná sa len príkaz1, po jeho skončení pokračuje prvým príkazom za celou
konštrukciou if. V opačnom prípade, ak hodnota podmienky je false, vykoná sa len príkaz2. Pre oba príkazy platí to, čo už bolo uvedené, ak sú jednoduché, píše sa za nimi
bodkočiarka, ak sú zložené, bodkočiarka sa nepíše. Nasledujúci program demonštruje
použitie if v druhej forme:
#include
<cstdlib>
#include <iostream>
//podmienený príkaz if 2. forma s else, vypise mensie zadane cislo
int main()
{
int x, y;
printf("Zadaj hodnotu X: "); scanf("%i",&x);
printf("Zadaj hodnotu Y: "); scanf("%i",&y);
printf("Zadana hodnota X = %i a Zadana hodnota Y = %i\n",x,y);
4
if (x < y)
printf("Mensia je hodnota X = %i\n",x);
else
{
if (y < x)
printf("Mensia je hodnota Y = %i\n",y);
else
printf("Zadane hodnoty su rovne X=%i a Y = %i\n",x, y);
}
system("PAUSE");
return 0;
}
Po spustení programu sa postupne zobrazia výzvy pre zadanie premenných x a y. Ich
hodnoty sa postupne vyhodnotia na výsledok, ktorá hodnota je menšia. Ak hodnoty premenných majú rovnakú hodnotu tak aj táto skutočnosť sa vypíše. Výsledok dokumentuje
nasledujúci obrázok:
Niekedy je potrebné vetviť program podľa viacerých alternatív. Jednou z možností
je nasledujúca konštrukcia, nie je ničím výnimočná, ide v skutočnosti o sériu dvojcestných
príkazov if.
if (podmienka1)
príkaz1
else if (podmienka2)
príkaz2
else if (podmienka3)
príkaz3...
...
else
príkazn;
Sémantika tejto konštrukcie je jednoduchá, postupne sa vyhodnocujú jednotlivé podmienky, podmienka1, podmienka2, podmienka3, a keď sa narazí na prvú, ktorej hodnota je
true, vykoná sa len jeho príslušný výkonný príkaz1 alebo príkaz2 alebo príkaz3 . V prípade, že ani jedna z podmienok nie je splnená, vykoná sa len príkazn, ak je uvedený, nemusí tam byť, v takom prípade sa jednoducho pokračuje prvým príkazom za celou konštrukciou if. Nasledujúci program demonštruje použitie if v tretej forme if else if. Program
je jednoduchá kalkulačka, po zadaní dvoch čísel, môžu byť aj desatinné, sa požaduje zadanie jedného zo štyroch znakov pre súčet +, pre rozdiel -, pre súčin * a pre podiel /. Ak sa
5
zadá iný znak mimo spomínaných znakov vypíše sa chybová správa „Zle zadany znak
operacie!!!!“
#include <cstdlib>
#include <iostream>
//podmienený príkaz if 3. forma s else if, znaky kalkulacka
int main()
{
float x, y, vysledok;
char z;
printf("Zadaj hodnotu X: "); scanf("%f",&x);
printf("Zadaj hodnotu Y: "); scanf("%f",&y);
printf("Zadana
hodnota
X
=
%6.2f
a
Zadana
hodnota
Y
=
%6.2f\n",x,y);
printf("Zadaj hodnotu znaku operacie + - * / \n");
scanf("%s",&z);
if (z == '+')
{vysledok = x + y;
printf("sucet %6.2f + %6.2f = %6.2f\n",x,y,vysledok); }
else if (z == '-')
{vysledok = x - y;
printf("rozdiel %6.2f - %6.2f = %6.2f\n",x,y,vysledok); }
else if (z == '*')
{vysledok = x * y;
printf("sucin %6.2f * %6.2f = %6.2f\n",x,y,vysledok); }
else if (z == '/')
{vysledok = x / y;
printf("podiel %6.2f / %6.2f = %6.2f\n",x,y,vysledok); }
else printf("Zle zadany znak operacie!!!!\n");
system("PAUSE");
return 0;
}
4.2. Prepínač switch
Umožňuje vykonávať vetvenie programu na viac ako dve vetvy. Vetvenie sa rovnako ako
v predchádzajúcom príkaze if vykonáva na základe vyhodnotenia výrazu, ktorý je celočíselného typu. Ak sa nájde zhoda medzi hodnotou výrazu a cestou case, pokračuje výpočet
touto vetvou, aj ostatným zostávajúcimi vetvami vrátane default. Ak sa zhoda nenájde vykoná sa len vetva default. Prvý tvar príkazu je:
switch (výraz)
{case hodn1 : prikaz1;
case hodn2 : prikaz2;
--------case hodnn : prikazn;
default : prikaz;}
Príklad použitia prepínača v tomto tvare demonštruje nasledujúci príklad, po spustení
programu sa požaduje zadanie známky, od 1 do 5, a potom sa vypíšu odpovedajúce texty.
6
{
int znamka;
printf("Zadaj hodnotu znamku: "); scanf("%i",&znamka);
switch (znamka)
{ case 1 : printf(" vyborne");
case 2 : printf(" chvalitebne");
case 3 : printf(" dobre");
case 4 : printf(" dostatocne");
case 5 : printf(" nedostatocne");
default : printf(" Zle zadana znamka \n"); }
system("PAUSE");
return 0; }
Ak sa zadá známka 1 potom sa v je dom riadku vypíše text: „vyborne chvalitebne dobre
dostatocne nedostatocne Zle zadana znamka“ Ak sa zadá známka 3 potom sa vypíše
text „dobre dostatocne nedostatocne Zle zadana znamka“ a ak sa zadá 5 tak sa vypíše
len text „nedostatocne Zle zadana znamka“. Ako však dosiahnuť, aby sa vypísal len jeden odpovedajúci text. Toto sa dá dosiahnuť použitím druhého tvaru príkazu switch, výpočet každej vetvy ukončený príkazom break, ktorý ukončí nielen danú vetvu ale aj celý príkaz switch.
switch (výraz)
{case hodn1 : prikaz1; break;
case hodn2 : prikaz2; break;
----------------case hodnn : prikazn; break;
default : prikaz; break; }
Preto v predchádzajúcom programe je každá vetva doplnená príkazom break a tak výsledný tvar programu môže byť:
{
int znamka;
printf("Zadaj hodnotu znamku: "); scanf("%i",&znamka);
switch (znamka)
{ case 1 : printf(" vyborne \n"); break;
case 2 : printf(" chvalitebne \n"); break;
case 3 : printf(" dobre \n"); break;
case 4 : printf(" dostatocne \n"); break;
case 5 : printf(" nedostatocne \n"); break;
default : printf(" Zle zadana znamka \n"); }
system("PAUSE");
return 0;
}
Spustenie programu vyžaduje zadanie hodnoty známky od 1 do 5. A tak po zadaní napríklad čísla 2 sa vypíše text chvalitebný. V prípade zadanie inej hodnoty, teda mimo 1 2 3 4
5, sa vypíše text „Zle zadaná známka“.
7
5. Príkazy cyklov
Príkazy cyklu sa používajú pre riadenie opakovania nejakého výpočtu. Určuje spôsob
a podmienku ukončenia opakovania. Jazyk C pozná tri varianty príkazu cyklu a každý má
svoje špecifické použitie:
- cyklus for – počet opakovania cyklu je známy
- cyklus while – ukončenie cyklu sa testuje na začiatku cyklu
- cyklus do....while – ukončenie cyklu sa testuje na konci cyklu
5.1.
Príkaz cyklu for
Príkaz má nasledujúcu syntax:
for (inicializácia_premennej; test_premennej; zmena_premennej) príkaz;
V prípade, že sa telo cyklu skladá z viacerých príkazov:
for (inicializácia_premennej; test_premennej; zmena_premennej) {
príkaz1;
príkaz2;
...
príkazn;
}
Príkaz pracuje takto:
1. najskôr sa vykoná inicializácia_premennej;
2. potom sa vykoná test_premennej a ak je podmienka splnená, vykoná sa:
a. telo cyklu;
b. zmena_premennej;
c. zopakuje sa bod 2.
Nasledujúci program vypíše čísla od 1 do 10:
#include <cstdlib>
#include <iostream>
int main()
{
int i;
for (i = 1; i<=10; i++)
{ printf("i=%2i \n", i); }
system("PAUSE");
return EXIT_SUCCESS;
}
Ďalší program vytvorí súčet všetkých čísel od 1 do 10, výsledok je 55:
int main()
{
int i, suma;
suma = 0;
for (i = 1; i<=10; i++)
{ suma = suma + i; }
8
printf("sucet cisel = %i \n", suma);
system("PAUSE");
return EXIT_SUCCESS;
}
Ak sa v tomto programe upraví príkaz cyklu for na tvar
for (i = 1; i<=10; i=i+2)
Vytvorí sa súčet nepárnych čísel od 1 do 10 výsledok je 25 a keď sa príkaz for zmení na
for (i = 2; i<=10; i=i+2)
potom sa vytvorí súčet párnych čísel od 1 do 10 výsledok je 30.
5.2.
Príkaz cyklu while
Tento príkaz cyklu patrí medzi cykly typu B a podmienka jeho vykonávania alebo ukončenia sa testuje hneď na začiatku končenie cyklu. Príkaz má nasledujúcu syntax:
while (podmienka) príkaz;
V prípade, že sa telo cyklu skladá z viacerých príkazov:
while (podmienka) {
príkaz1;
príkaz2;
...
príkazn;
}
Príkaz pracuje takto:
1. Najskôr sa vyhodnotí podmienka, ak je splnená pokračuje sa bodom 2., ak je výsledok
podmienky nesplnený cyklus skončí. To znamená, že telo cyklu sa nemusí vôbec vykonať.
2. Vykonávanie príkazov tela cyklu, v tele cyklu sa musí zabezpečiť modifikácia nejakej
premennej tak aby podmienka bola splnená, inak vznikne nekonečný cyklus.
Použitie príkazu while demonštruje nasledujúci príklad, ktorý tiež vytvorí súčet
všetkých celých čísel od 1 do 10, výsledok je 55.
#include <cstdlib>
#include <iostream>
// while - sucet cisel od 1 do 10
int main()
{
int i, suma;
suma = 0; i = 1;
while (i <=10)
{ suma = suma + i;
i++; }
printf("sucet cisel = %i \n", suma);
system("PAUSE");
return EXIT_SUCCESS;
}
9
Nasledujúci program vypočítava hodnoty funkcie
pre x z intervalu
<0 až 5> s krokom x = 0,5.
#include <cstdlib>
#include <iostream>
#include <math.h>
// while - vypocet funkcie
int main()
{
float x, y;
x = 0;
while (x <=5)
{ y = (x - 4)/pow((x+2),2);
printf("x = %6.2f y = %6.2f\n", x, y);
x = x + 0.5;
}
system("PAUSE");
return EXIT_SUCCESS;
}
Výsledok spustenia programu zobrazuje nasledujúci obrázok:
5.3.
Príkaz cyklu do.....while
Tento príkaz cyklu patrí medzi cykly typu B a podmienka jeho vykonávania alebo ukončenia sa testuje až na konci cyklu. Príkaz má nasledujúcu syntax:
do príkaz;
while (podmienka);
V prípade, že sa telo cyklu skladá z viacerých príkazov:
do {
príkaz1;
príkaz2;
...
príkazn; }
while (podmienka);
Príkaz pracuje takto:
10
1. Telo cyklu sa začne vykonávať bez akýchkoľvek obmedzení až sa dostane na príkaz
while s podmienkou.
2. Podmienka sa najskôr sa vyhodnotí, ak je splnená pokračuje sa bodom 1., ak je výsledok podmienky nesplnený cyklus skončí. To znamená, že telo cyklu sa musí vykonať
aspoň raz.
Použitie príkazu do....while demonštruje nasledujúci príklad, ktorý tiež vytvorí súčet všetkých celých čísel od 1 do 10, výsledok je 55.
#include <cstdlib>
#include <iostream>
// do while - sucet cisel od 1 do 10
int main()
{ int i, suma;
suma = 0; i = 1;
do {
suma = suma + i;
i++; }
while (i <=10);
printf("sucet cisel = %i \n", suma);
system("PAUSE");
return EXIT_SUCCESS;
}
Nasledujúci program vypočítava hodnoty funkcie
pre x z intervalu <0 až 5>
s krokom x = 0,5.
#include <cstdlib>
#include <iostream>
#include <math.h>
// while - vypocet funkcie
int main()
{
float x, y;
x = 0;
do
{ y = pow(x - 4,3)/sqrt(x+3);
printf("x = %6.2f y = %6.2f\n", x, y);
x = x + 0.5;
}
while (x <=5);
system("PAUSE");
return EXIT_SUCCESS;
}
Výsledok spustenia programu zobrazuje nasledujúci obrázok:
11
6. Príkazy skokov
Ich názov napovedá, čo bude ich náplňou. Pod skokom rozumieme okamžitú nepodmienenú zmenu postupnosti vykonávaných príkazov programu. Aj príkazy výberu a príkazy
cyklu zahŕňajú zmenu toku programu, ale viac-menej podmienenú a akosi skrytú, takže
pod skokovými príkazmi budeme rozumieť len tie, ktorými explicitne meníme lineárny beh
programu. Skokové príkazy sú v C++ štyri: break, continue, return a goto.
6.1.
Príkaz break
Príkaz break o tomto príkaze sme si už hovorili – bolo to v súvislosti s príkazom switch,
kde príkaz break slúžil na opustenie bloku, tvoriaceho výkonný príkaz príkazu switch. Okrem toho break môžeme použiť aj v tele ľubovoľného príkazu cyklu. V oboch prípadoch je
jeho účinok rovnaký, teda ukončenie daného príkazu, inak povedané, vyskočenie z jeho
výkonného bloku. Toto vyskočenie sa týka najbližšieho bloku smerom zvnútra von. Použitie príkazu ukazuje nasledujúci príklad.
#include <cstdlib>
#include <iostream>
// priklad break
int main()
{
int i, j;
for (i = 0; i < 5; i++)
{
for (j = 0; j < 5; j++)
{ printf("i = %i j = %i \n", i, j);
if (j == 3) break;
}
if (i == 4) break;
}
system("PAUSE");
return EXIT_SUCCESS;
}
V programe sú spustené dva cykly, vonkajší cyklus s riadiacou premennou i a vnútorný
cyklus s riadiacou premenou j. Oba cykly majú riadiace premenné nastavené od 0 do 5.
V bloku vnútorného cyklu sa riadiaca premenná j porovnáva s hodnotou 3 a keď ju nadobudne príkaz break vnútorný cyklus sa preruší a pokračuje sa vonkajším cyklom. V bloku
vonkajšieho cyklu sa riadiaca premenná i testuje na hodnotu 4 ak keď ju nadobudne vonkajší cyklus skončí. Hodnoty riadiacich premenných i a j sa zobrazujú podľa obrázku.
Z výpisu je vidieť, že premenná i sa mení od 0 do 4 a premenná j sa mení od 0 do 3.
12
6.2.
Príkaz continue
Príkaz continue tento príkaz má podobnú oblasť použitia ako príkaz break, na rozdiel od
neho však je možné príkaz continue použiť iba v príkazoch cyklu. Jeho funkcia je jednoduchá – spôsobí okamžité ukončenie práve prebiehajúcej iterácie a pokračovanie ďalšou
iteráciou daného cyklu. Podobne ako break aj continue sa vzťahuje na najbližší blok cyklu.
Jeho použitie demonštruje nasledujúci program, vytvorí súčet párnych čísel od 0 do 10.
Test if(i % 2 != 0) continue; zisťuje či zvyšok celočíselného delenia dvomi je
nenulový, ak je nenulový, príkazom continue sa iterácia pre riadiacu premennú i preruší
a pokračuje sa ďalšou iteráciou.
#include <cstdlib>
#include <iostream>
// prikaz sucet parnych cisel s continue
int main()
{
int Sumaparne;
Sumaparne = 0;
for(int i=0; i<=10; i++) {
if(i % 2 != 0) continue; // ukoncenie iteracie
else Sumaparne += i;
} //ak i je neparne
printf("Sucet cisel = %i \n", Sumaparne);
system("PAUSE");
return EXIT_SUCCESS;
}
6.3.
Príkaz return
Príkaz return Tento príkaz sa používa na ukončenie behu práve vykonávanej funkcie a
návrat do funkcie volajúcej, s prípadným odovzdaním návratovej hodnoty. Jeho syntax je
nasledujúca:
return výraz;
return;
Výraz predstavuje návratovú hodnotu a je povolený iba vtedy, ak je funkcia deklarovaná s
návratovým typom iným ako void (inými slovami, ak vôbec niečo vracia). Vo funkciách typu
13
void je povolený iba druhý tvar, bez výrazu. Prirodzené ukončenie funkcie, keď sa dospeje
k pravej krútenej zátvorke, ukončujúcej zápis funkcie, je ekvivalentné príkazu return bez
výrazu. O funkciách sa zatiaľ veľa nepovedalo, takže len malý príklad. Funkcia, ktorá vracia výsledok výrazu f(x) = x2 + 3x – 6:
#include <cstdlib>
#include <iostream>
// vypocet funkcie s return
float funkcia(float x1) // deklaracia funkcie
{
return x1*x1 + 3*x1 - 6;
}
int main()
{
float x, y;
x = 0;
do
{ printf("x = %6.2f y = %6.2f\n", x, funkcia(x));
x = x + 0.5;
}
while (x <=5);
system("PAUSE");
return EXIT_SUCCESS;
}
Spustenie programu zobrazí výsledky:
6.4.
Príkaz goto
Príkaz goto posledným zo skokových príkazov, najviac oprávneným nosiť názov príkaz
skoku, je príkaz goto. Jeho syntax je jednoduchá:
goto návestie;
kde návestie sa môže vyskytovať pred ľubovoľným príkazom vo funkcii a má tvar identifikátora ukončeného dvojbodkou:
návestie:
príkaz;
príkaz;
14
Čo sa stane, keď program narazí na príkaz goto? Jednoducho skočí na prvý príkaz nasledujúci za daným návestím. V prípade, že chceme skočiť na koniec nejakého bloku a za
návestím by už teda nebol nijaký príkaz, iba pravá krútená zátvorka, musíme tam nejaký
príkaz pridať, a to najčastejšie prázdny príkaz, teda bodkočiarku:
while (...)
{
...
goto end;
...
end:
;
}
Používanie príkazu goto je diskutabilné. Veľa programátorov jeho použitie popierajú a iní
sa k nemu hlásia ale len v niektorých špecifických prípadoch. Bližšie informácie sú na webe. Ale treba povedať aj toto: V súčasnej dobe bežné programovacie jazyky, buď majú vo
svojej štruktúre zaradený príkaz goto alebo tento príkaz nemajú dispozícií. Ale obe tieto
skupiny jazykov majú k dispozícii nástroje ako príkaz goto nepoužiť. A keď je nutné, tento
príkaz použiť, asi je potrebné navrhnúť a prehodnotiť algoritmus a spraviť hlbšiu anylýzu.
7. Funkcie
V tejto kapitole si podrobnejšie rozoberieme základný stavebný kameň jazyka C funkciu. Z predchádzajúceho textu vieme, že každý C program obsahuje aspoň jednu
funkciu - main(). Prečo je za main napísaná dvojica zátvoriek? Takto spoznáme funkciu
od identifikátora iného typu funkcie main() vracia hodnotu typu int. Funkcia v sebe zahrnuje také príkazy, ktoré sa v programe často opakujú a preto sa vyplatí ich vyčleniť, pomenovať a volať. Predovšetkým rozlišujme štandardné funkcie, užívateľské funkcie
a podporné a nadstavbové funkcie.
Štandardné funkcie, preddefinované funkcie sú definované normou jazyka a výrobca
prekladača ich dodáva ako súčasť programového balíku tvoriaceho prekladač a jeho podporné programy a súbory. Tieto štandardné funkcie spravidla dostávame ako súčasť štandardných knižníc (preto sa im niekedy hovorí knižnica funkcií) a ich deklarácia je popísaná
v hlavičkových súboroch, ale nie je dispozícii ich zdrojový kód.
Užívateľské funkcie sú tie funkcie, ktoré sme napísali a máme ich zdrojové texty. Pokiaľ
sme profesionáli, vyplatí sa nám naše funkcie precízne dokumentovať a archivovať. Keď
už sme ich raz napísali a odladili, môžeme ich v budúcnosti s dôverou už len používať.
Môže byť účelné združovať viac užívateľských funkcií do jedného, prípadne niekoľkých,
súborov prípadne z nich vytvoriť knižnicu, aby sme ich pri každom použití nemuseli znovu
prekladať.
15
Podporné a nadstavbové funkcie sem zaradujú nielen funkcie od tzv. tretích výrobcov,
podpora pre spoluprácu s databázami, volanie modemu, faxu, užívateľské rozhranie, ale aj
rozšírenie prekladača o funkcie nedefinované normou jazyka, funkcie implementačne závislé a podobne.
Download

Príkazy jazyka CPP