6. Riadenie chodu programu

Transcription

1 6. Riadenie chodu programu 6.1. Výrazový príkaz 6.2. Prázdny príkaz 6.3. Bloky Oblasť platnosti identifikátora 6.5. Podmienený príkaz if-else Prepínač 6.7. Cykly Cyklus while Cyklus for Cyklus do 6.8. Príkaz skoku V doterajšom výklade sme sa dozvedeli, že sa program skladá z funkcie main() a z príkazov, ktoré táto funkcia obsahuje. Svoje intuitívne predstavy o programe rozšírime nielen o prípadné ďalšie funkcie, ale detailnejšie sa pozrieme aj na obsah funkcií. Telo funkcie obsahuje rad príkazov. Naším cieľom je prevádzať práve tie príkazy, ktoré odpovedajú zvolenému zámeru. Výber z príkazov je určený stavom doterajšieho behu programu, vstupnými údajmi a riadiacimi štruktúrami, ktoré sme použili. Program, prevádzajúci príkazy v pevnom a nemennom poradí, ktorý zodpovedá ich umiestnení v zdrojovom texte a naviac bez možnosti ich výberu, iste nieje naším ideálom. A to bez ohľadu na zvolený vyšší programovací jazyk. Cieľom tejto kapitoly je preto zoznámenie sa s riadiacimi štruktúrami. Pred podrobným prístupom najprv uveďme prehľadne príkazy, ktoré máme v C k dispozícii: výrazový príkaz blok podmienený príkaz prepínač cyklus skok 6.1. Výrazový príkaz Výraz poznáme z predchádzajúceho textu. Výrazom je nielen aritmetický výraz (napríklad a + b, či * a), jednoduchý výskyt konštanty (literálu) či premennej, ale aj funkčné volanie a priradenie. Ak výraz ukončíme symbolom ; (bodkočiarka), získame výrazový príkaz.

2 6.2. Prázdny príkaz Prázdny príkaz je výrazový príkaz, v ktorom nie je výrazová časť. Táto konštrukcia nie je tak nezmyselná, ako sa na prvý pohľad môže zdať. Dáva nám v niektorých prípadoch možnosť umiestniť nadbytočnú bodkočiarku ; do zdrojového textu. Napríklad aj za vnorený blok. Pretože sa o prázdnom príkaze môžeme ťažko dozvedieť niečo ďalšieho, podívajme sa radšej na ďalšie príkazy jazyka C Bloky. Všade v C, kde sa môže vyskytovať príkaz, sa môže vyskytovať aj zložený príkaz. Zložený príkaz je postupnosťou príkazov. Konštrukcia, ktorá zložený príkaz vymedzuje, začína ľavou a končí pravou zloženou zátvorkou, a nazýva sa blok. V bloku môžeme, okrem už spomínanej realizácie zloženého príkazu, prevádzať lokálnu deklaráciu a definíciu. Tie však iba na začiatku bloku. Ich platnosť je obmedzená na blok a prípadné ďalšie vnorené bloky. Vnorený blok nemusí byť ukončený bodkočiarkou. Predstavuje zložený príkaz a jeho koniec je jasne určený. Nie je na škodu si uvedomiť, že telo každé funkcie je blokom. Preto sme mohli v tele funkcie main() definovať a používať lokálne premenné. Syntakticky môžeme blok popísať následovne: [declaration_1[; declaration_2... ];] [statement_1 [; statement_2... ] ] Blok teda môže obsahovať žiadnu, jednu či viacero deklarácii. Pokiaľ deklaráciu obsahuje, musí byť od ďalšej časti bloku oddelená bodkočiarkou. Ďalej blok môže obsahovať jednotlivé príkazy, rovnako oddelené bodkočiarkou. Všimnime si, že posledný z príkazov nemusí byť od uzatváracej zloženej zátvorky bloku oddelený bodkočiarkou Oblasť platnosti identifikátoru Identifikátor, ktorý deklarujeme či definujeme, si ponecháva svoju platnosť v programe, v ktorom je deklarovaný či definovaný. Jeho meno je v tomto rozsahu viditeľné, ak nie je maskované: Na úrovni súboru je rozsah platnosti deklarácie vymedzená miestom, kde je deklarácia dokončená, a koncom prekladanej jednotky. Deklarácia na úrovni argumentu funkcie má rozsah od miesta deklarácie argumentu v rámci definície funkcie až do ukončenia vonkajšieho bloku definície funkcie. Pokiaľ sa nejedná o definíciu funkcie, končí rozsah deklarácie argumentu s deklaráciou funkcie. V rámci bloku je deklarácia platná v rozsahu jej dokončenia až do konca bloku. Meno makra je platné od jeho definície (direktívou define) až do miesta, kedy je definícia odstránená (direktívou undef, pokiaľ vôbec odstránená je). Meno makra nemôže byť maskované.

3 6.5. Podmienený príkaz if-else. Operátor podmieneného výrazu? : používame pre výber časti výrazu. Pre výber z príkazov máme k dispozícii podmienený príkaz. Mohli by sme povedať, že sa jedná o príkazy dva. Ich syntaktický zápis je nasledovný if ( <expression> ) <statement1>; if ( <expression> ) <statement1>; else <statement2>; Význam príkazu if je nasledujúci. Po vyhodnotení výrazu expression (musí byť v zátvorkách) sa v prípade jeho nenulovej hodnoty prevedie príkaz statement1. Po jeho prevedení pokračuje program za týmto príkazom. V prípade nulového výsledku výrazu sa riadenie programu predá bezprostredne za podmienený príkaz. Inak povedané sa príkaz statement1 preskočí. Príkaz if môžeme použiť aj s variantom else. Sémantika takého príkazu if-else je v prvej časti totožná so samotným if. Ak je výslednou hodnotou výrazu expression jedna (nenulová hodnota), prevedie sa príkaz statement1. V opačnom prípade, kedy výsledkom je nula, sa prevedie príkaz statement2. V oboch prípadoch sa riadenie programu po prevedení prvého, respektíve druhého, príkazu predá za celý podmienený výraz. Príkaz if Príkaz else Niekedy sa výklad sémantiky predkladá spôsobom, kedy sa nulovej hodnote hovorí nepravda a nenulovej (jedničke) pravda. Ako je už známe z logických výrazov. Potom môžeme v druhej variante povedať, že ak je podmienka splnená, vykoná sa prvý príkaz statement1, inak príkaz druhý statement2. Zdôraznime, že oba príkazy sú ukončené bodkočiarkou.

4 Z predchádzajúcich odstavcov vieme, že miesto príkazu môže byť umiestnený blok. V takom prípade je príkaz jasne vymedzený a bodkočiarku za blokom pred else nepíšeme! Príklad nám ukáže použitie podmieneného príkazu if-else. Máme vypočítať a zobraziť podiel dvoch zadaných racionálnych čísel. Pretože je známe, že nulou deliť nemôžeme, využijeme podmienený príkaz na ošetrenie tohoto obmedzenia. /* subor if-else1.c */ #include <stdio.h> int main(void) float a, b; puts("zadaj dve racionalne cisla:"); scanf("%f %f", &a, &b); if (b == 0.0) puts("\b\nnulou delit nejde!\n"); else float podiel; podiel = a / b; printf("ich podiel je: %10.2f\n", podiel); return 0; Ako prvý príkaz po teste if je jednoduchý výstup reťazca puts(). Je ukončený bodkočiarkou a nasleduje kľúčové slovo else. Príkaz v tejto časti je tvorený blokom. Za blokom bodkočiarka nie je. Pokiaľ by tam bol, bol by chápaný ako prázdny príkaz. Tak je interpretovaná aj bodkočiarka za posledným príkazom v bloku. V úvode tejto kapitoly sme si zhrnuli príkazy jazyka C. Neprekvapí nás teda umiestnenie podmieneného príkazu if ako jedného z príkazov if-else. Spravidla sa umiesťuje na miesto druhého príkazu. Výsledná konštrukcia býva často nazývaná if-else-if: if ( <expression1> ) <statement1>; else if ( <expression2> ) <statement2>; else if ( <expression3> ) <statement3>;... else if ( <expressionn> ) <statementn>; else <statementn+1>; Jej často využívanou vlastnosťou je skutočnosť, že sa prevedie práve jeden z príkazov. Pokiaľ nie je posledný príkaz bez podmienky statementn+1 uvedený, nemusí sa previesť žiadny. Inak povedané, prevedie sa nejviac jeden. Zapamätajme si dobre túto konštrukciu. Nie len pre jej užitočnosť. Po príklade ju budeme môcť porovnať s konštrukciou zvanou prepínač. Našou úlohou je programovo ošetriť, aký alfanumerický znak bol zadaný. Prípadne dať správu o zadaní znaku iného. Pretože je isté, že zadaný znak patrí práve do jednej z tried malé

5 písmená, veľké písmená, číslice a iné, použijeme konštrukciu podmieneného príkazu. Pri použití if-else by pre každú triedu bola znovu testovaná príslušnosť načítaného znaku. Bez ohľadu, či znak už niektorú z predchádzajúcich podmienok splnil. Použitá konštrukcia ifelse-if prípadné nadbytočné testy odstráni. Vždy bude vybraný práve jeden z príkazov. Pripomeňme si logický výraz, ktorý tvorí podmienku if ((znak >= 'a') && (znak <= 'z')) Vonkajšie zátvorky sú povinné, lebo ohraničujú podmienku príkazu if. Vnútorné zátvorky naopak uviesť nemusíme. Priorita operátora && je nižší než relačných operátorov <= a >=. Zátvorky sme aj tak uviedli, lebo zvyšujú čitateľnosť. Celý výpis zdrojového textu nasleduje. /* subor if-else2.c */ #include <stdio.h> int main(void) int znak; printf("zadaj alfanumericky znak:"); scanf("%c", &znak); printf("\nzadal si "); if ((znak >= 'a') && (znak <= 'z')) printf("male pismeno\n"); else if ((znak >= 'A') && (znak <= 'Z')) printf("velke pismeno\n"); else if ((znak >= '0') && (znak <= '9')) printf("cislicu\n"); else printf("\nnezadal si alfanumericky znak!\n"); return 0;

6 6.6. Prepínač Prepínač slúži na rozdelenie postupnosti príkazov na časti, následné vybranie a prevedenie niektorej, či niektorých z nich. Pokiaľ nám táto formulácia prepínač príliš nepriblížila, pokúsme sa inak. Prepínač slúži na vetvenie výpočtu podľa hodnoty celočíselného výrazu. Syntakticky zapísaný príkaz prepínač má tento tvar: switch ( <expression> ) <statement> case <constant expression> : default : Syntaktickú definíciu prepínača však musíme upresniť. Po kľúčovom slove switch nasleduje celočíselný výraz expression uzavretý v zátvorkách. Za ním je príkaz statement, väčšinou tvorený blokom. Blok predstavuje postupnosť príkazov, v ktorých môžu byť umiestnené návestia, ktorých syntax vidíme na druhom riadku definície. Riadiaci príkaz tvorí celočíselný konštantný výraz constant expression uvádzaný kľúčovým slovom case a ukončený dvojbodkou :. Jedno z návestí môže byť kľúčovým slovom default, prirodzene ukončeným dvojbodkou :. Sémantika prepínača je pomerne zložitá. Popíšeme si jednotlivé pravidlá, ktorými sa riadi: Program vyhodnotí konštantný výraz a jeho hodnotu porovnáva s každým z case návestí prepínača. Návestie case môže byť obsiahnuté vo vnútri iných príkazov (v rámci prepínača), okrem prípadného vnoreného prepínača. V jednom prepínači sa nesmú používať dva návestia s rovnakou hodnotou. Ak nastane zhoda hodnoty case návestia s hodnotou switch výrazu expression, je prenesené riadenie programu na toto návestie. Inak je riadenie prenesené na návestie default v rámci príslušného prepínača. Pre návestie default platia rovnaké zásady ako pre iné návestia. Pokiaľ nenapíšeme default návestie a hodnota výrazu switch sa nebude zhodovať so žiadnym z návestí, bude riadenie prenesené na príkaz nasledujúci za prepínačom. Pokiaľ program pri prevádzaní prepínača vykoná príkaz break, bude riadenie prenesené na príkaz nasledujúci za prepínačom. Príkaz break môže byť v rámci prepínača umiestnený v ľubovolných príkazoch, okrem prípadných vnorených do, for, switch alebo while príkazoch. Prepínač switch môže mať mnoho foriem. Pozrime sa na príklad, v ktorom použijeme jednu z nich. Našou úlohou je podať informáciu o tom, aká hodnota padla pri simulovanom hode kocky. Miesto kocky použijeme generátor pseudonáhodných čísel (ďalej im budeme hovoriť len náhodné). Pretože takú elektronickú kocku budeme používať aj v príklade v nasledujúcom odstavci, venovanom cyklom, preberieme si funkcie s ňou spojených podrobnejšie.

7 Pomocou funkcie srand()nastavíme postupnosť náhodných čísel. Ako počiatočnú hodnotu nemôžeme zvoliť konštantu, lebo potom by bola generovaná postupnosť náhodných veličín vždy rovnaká. Preto potrebujeme vhodnú hodnotu, ktorá bude pri každom spustení programu iná. Takto vhodne sa mení napríklad čas. Preto použijeme ako argument návratovú hodnotu funkcie time(). Iné zámery s funkciou time() nemáme, preto použijeme ako jej argument NULL. Nesmieme však zabudnúť čas správne pretypovať. A generátor máme pripravený: srand((unsigned) time(null) ); Teraz musíme vedieť kockou hádzať. Pri volaní funkcie rand() dostávame náhodné celé číslo v rozsahu 0 až RAND_MAX. 16 bitový BC31 definuje túto hodnotu ako MAXINT, konkrétne Pre našu potrebu stačí číslo v rozsahu 0 až 5, ku ktorému pripočítame jedničku. Túto prácu prevedie operácia modulo šiestich. switch (rand() % 6 + 1) Získaná hodnota 1 až 6 je výrazom prepínača switch. V závislosti na tejto hodnote sa riadenie programu prenesie na konštantné návestie. Problém je v tom, že pokiaľ by sme takto označenú postupnosť príkazov neukončili príkazom break, pokračoval by od návestia program ďalej, až po koniec prepínača. Aj táto vlastnosť sa dá využiť. Ukážku vidíme v spojenom hlásení pre hodnoty 2 a 3. Umiestnenie návestia default v prepínači je ľubovolné. Spravidla sa píše na koniec, čo je pomerne zakorenený zvyk. Budeme ich rovnako dodržovať. /* subor switch-1.c */ #include <stdlib.h> #include <stdio.h> #include <time.h> int main(void) char *s; printf("\nhadzem kockou...\n"); srand((unsigned) time(null) ); switch (rand() % 6 + 1) case 1: s = "jednotka"; case 2: case 3: s = "dvojka alebo trojka"; case 4: s = "stvorka"; case 5: s = "patka"; default: s = "sestka"; printf("\npadla %s.\n\n", s); return 0;

8 Ak porovnáme prepínač s konštrukciou if-else-if, vidíme zásadne rozdiely: 1. Rozhodovací výraz if môže testovať hodnoty akéhokoľvek typu, zatiaľ čo rozhodovací výraz príkazu switch musí byť výhradne celočíselným výrazom. 2. V konštrukcii if-else-if sa prevedie najviac (alebo podľa použitia práve) jeden z príkazov. Aj pri prepínači sa nemusí previesť žiadny z príkazov. Môže ich byť však prevedených viac. Konštantné návestie určuje iba prvý z nich. Pokiaľ chceme, oddelíme nasledujúce príkazy príkazom break. 3. V prepínači sa návestie default môže vyskytovať kdekoľvek. Zodpovedajúci variant v konštrukcii ifelseif môže byť umiestnený iba na konci Cykly Cyklus je časť programu, ktorá je v závislosti na podmienke prevádzaná opakovane. U cyklu obvykle rozlišujeme riadiacu podmienku cyklu a telo cyklu. Riadiaca podmienka cyklu určuje, či bude prevedené telo cyklu, alebo bude riadenie predané za príkaz cyklu. Telo cyklu je príkaz, spravidla v podobe bloku. Cykly môžeme rozdeliť podľa toho, či sa telo prevedie aspoň jedenkrát, a cykly, kde telo nemusí byť prevedené vôbec. Rozhodne môžeme povedať, že aj keď v C existujú rôzne typy cyklov, je možné vystačiť s jedným z nich. Aj tak si v tejto podkapitole povieme o všetkých. Ich výber ponecháme na vhodnosti použitia v danej situácii aj na ich individuálnej obľube. V časti venovanej príkazu while si popíšeme niektoré vlastnosti spoločné pre všetky cykly. Postupne teda while, for a do. Cyklus while Príkaz while, vykonáva príkaz statement (telo cyklu) viackrát, alebo vôbec, pokiaľ má v danom kontexte testovací výraz expression nenulovou hodnotu. Syntax príkazu while je nasledujúci: while ( <expression> ) <statement> Príkaz je veľmi často blokom. Tu sa najmä začiatočníci mylne domnievajú, že pokiaľ sa kontext kdekoľvek behom prevádzania príkazov bloku tela cyklu zmení, a podmienka tak prestane byť splnená, je cyklus ukončený. To však nie je pravda. Pravidlo hovorí, že sa príkaz statement prevedie, ak je podmienka expression splnená. Ak je príkazom blok, prevedie sa teda blok celý. Až potom sa znovu prevedie test. Názornejšie bude, pozrieť sa na vývojový diagram.

9 Vo vývojovom diagrame sa vyskytujú nepovinné príkazy break a continue. S prvým z nich sme sa už stretli pri prepínači. Druhý zatiaľ nepoznáme. Ich sémantiku, zakreslenú vo vývojovom diagrame, si teraz popíšeme. Najprv poznamenajme, že obidva sú pokladané za prostriedky štruktúrovaného programovania. Príkaz break má vo všetkých cykloch rovnaký význam. Ukončí prevádzanie príkazov tela cyklu a predá riadenie prvému príkazu za príkazom while. Týmto spôsobom môžeme bezprostredne ukončiť priebeh cyklu bez ohľadu na hodnotu podmienky. Príkaz continue rovnako ukončí prevádzanie príkazov tela cyklu. Riadenie však predá tesne pred príkaz cyklu. Prebehne teda vyhodnotenie testovacieho výrazu a podľa jeho hodnoty pokračuje program rovnako, ako by bolo telo cyklu vykonané do konca (teda bez predčasného ukončenia vykonaním continue). Podobne ako break, má príkaz continue vo všetkých cykloch rovnaký význam. Použitie príkazu while ukazuje príklad. Opäť v ňom používame kocku. S ňou súvisiace funkcie sme popísali v predchádzajúcom príklade. Tentokrát je naším cieľom sčítať počet pokusov, potrebných na to, aby sme hodili šestku POCET-krát. Súčasne s novou látkou si pripomenieme niektoré poznatky z predchádzajúcich kapitol. Konštanta POCET, ktorá nemá uvedený typ má implicitne typ int. Kľúčovým slovom static použitým pri deklarácii premenných celkom a pocet (je to iný identifikátor než POCET), nielen umiestňujeme tieto premenné do dátového segmentu programu, ale zároveň je im pri spustení programu definovaná počiatočná hodnota nula. Vďaka tomu ich ďalej nemusíme inicializovať. Cyklus while samotný prebieha tak dlho, dokiaľ platí podmienka (pocet < POCET). Za blokom, tvoriacim príkaz cyklu, nemusíme písať ukončovaciu bodkočiarku. Nasleduje formátovaný štandardný výstup výsledku a záver funkcie main(). /* subor while-1.c */ #include <stdlib.h> #include <stdio.h> #include <time.h> const POCET = 10; int main(void) static int celkom, pocet; printf("\nhadzem kockou pokial mi nepadne %d-krat sestka....\n", POCET); srand((unsigned) time(null) ); while (pocet < POCET) celkom++; if ((rand() % 6 + 1) == 6) pocet++; printf("\na je to! Hodov bolo celkom %d.\n\n", celkom); return 0;

10 Nasledujúci príklad ukazuje použitie príkazu while spolu s if-else-if a príkazy break a continue. Našou úlohou je porovnanie dvoch načítaných reťazcov a zobrazenie menšieho z nich. Tento príklad používa aritmetiku ukazovateľov, preberanú v rámci jednej z ďalších kapitol. V tomto okamihu prijmeme skutočnosť, že prostredníctvom ukazovateľov porovnávame ASCII hodnoty jednotlivých znakov odpovedajúcich reťazcov. Každý reťazec je ukončený znakom s kódom nula. Zvolená mnemonika pomenúva dva reťazce a a b, ukazovatele na, respektíve do, týchto reťazcov pa a pb. Identifikátor pk predstavuje ukazovateľ na kratší z porovnávaných reťazcov. Algoritmus úlohy porovnáva postupne znaky oboch reťazcov, pokiaľ sú si rovné: else if (*pa == *pb) pa++; pb++; continue; Použitie continue nie je v našom prípade nevyhnutné. Vďaka if-else-if nemôže v tejto vetve tela cyklu nasledovať iný príkaz. Naopak break v oboch ďalších vetvách opúšťa cyklus. Ukončuje tým porovnávanie reťazcov a určuje kratší z nich. V prvom zo zmienených prípadov je if (*pa < *pb) pk = a; hodnota znaku v reťazci a menší, než v reťazci b. a je teda kratší. Cyklus je ukončený. Ďalej by sme totiž opustili definovaný rozsah reťazca a. A pretože je podmienka cyklu napísaná tak, že zaisťuje jeho opakovanie, pokiaľ nenarazíme na koniec aspoň jedného z reťazcov: while ((*pa!= 0x0) && (*pb!= 0x0)) /* '\0' 0 */ Máme istotu, že pokiaľ nenastali predchádzajúce možnosti, musí platiť: else pk = b; Teda, že kratší je druhý reťazec. Tesne za telom cyklu máme ošetrenú variantu, keď skončí druhý z reťazcov skôr. Potom je kratším z reťazcov. Nám neostáva, než ho zobraziť a ukončiť program. Nasleduje neprerušený výpis zdrojového textu riešenia.

11 /************************************************/ /* subor cmp_str.c - compare two strings */ /* porovna dva nacitane retazce a zobrazi mensi */ /************************************************/ #include <stdio.h> #define DLZKA 50 int main(void) char a[dlzka], b[dlzka], *pa, *pb, *pk; /* pa[], pb[], pk[] */ pk = pa = gets(a); pb = gets(b); while ((*pa!= 0x0) && (*pb!= 0x0)) /* '\0' 0 0x0 - toiste*/ if (*pa < *pb) pk = a; else if (*pa == *pb) pa++; pb++; continue; else pk = b; if ((*pa!= 0x0) && (*pb == 0x0)) pk = b; puts("\nkratsi je:"); puts(pk); return 0; Cyklus for Príkaz for prevádza príkaz statement viackrát, alebo vôbec, pokiaľ je hodnota nepovinného testovacieho výrazu expr2 nenulová. V príkaze for môžeme ešte napísať dva ďalšie výrazy s vedľajším efektom, expr1 a expr3. Syntaxe for: for ( [<expr1>] ; [<expr2>] ; [<expr3>] ) <statement> Nepovinný výraz expr1 je prevedený pred prvým vyhodnotením testu. Typicky sa používa pre inicializáciu premenných pred cyklom. Po každom prevedení tela cyklu statement, prevedie program nepovinný výraz expr3. Typicky sa jedná o prípravu ďalšej iterácie cyklu. Pokiaľ neuvedieme testovací výraz expr2, použije prekladač hodnotu 1, a teda bude prevádzať nekonečný cyklus. Našťastie môžeme použiť príkazy break a continue s rovnakým významom, aký sme popísali pri while.

12 Vývojový diagram úplného variantu príkazu for je na obrázku, v ktorom sme ponechali značenie zodpovedajúce vyššie uvedenému syntaxu: Pre tlač ASCII tabuľky znakov s kódmi 32 až 127 použijeme príkaz for v úplnej variante: for (znak = ' '; znak < 128; znak++) V tomto prípade môžeme nazývať premennú znak riadiacou premennou cyklu. Pred testom ju inicializujeme medzerou, teda prvým zobraziteľným ASCII znakom. Nasleduje test na hodnotu 128. Prevádza sa pred každým priechodom telom cyklu. Ak nie je podmienka splnená, pokračuje sa za cyklom. Po každom priechode telom cyklu je riadiaca premenná cyklu znak zvýšená o jedna. Tak je pripravený ďalší priechod cyklom s hodnotou následného ASCII znaku. Samotné telo cyklu vlastne len zobrazuje jednotlivý znak. Ak je jeho ASCII hodnota deliteľná 16 bezo zbytku, zaistí vysielanie konca riadku tvar tabuľky. /* subor for-1.c */ #include <stdio.h> int main(void) int znak; putchar('\n'); for (znak = ' '; znak < 128; znak++) if (znak % 16 == 0) putchar('\n'); putchar(znak); putchar('\n'); return 0; /*!"#$%&'()*+,-./ PQRSTUVWXYZ[\]^_ `abcdefghijklmno pqrstuvwxyz ~&127 */

13 Cyklus do Príkaz do je jediným z cyklov, ktorý zaisťuje aspoň jedno prevedenie tela cyklu. Inak povedané, jeho testovací príkaz statement je testovaný až po priechode telom cyklu. Pokiaľ je test splnený, prevádza sa telo cyklu. Po syntaktickej stránke tvorí telo cyklu opäť výraz expression: do <statement> while ( <expression> ); Vývojový diagram príkazu do túto vlastnosť ukazuje ešte názornejšie: Príkazy break a continue v tele cyklu sa chovajú rovnako, ako v cykloch ostatných. Po break je cyklus opustený, zatiaľ čo po continue je prevedený výraz expression a podľa jeho výsledku sa pokračuje ďalej. Časté použitie príkazu do nájdeme napríklad v tých numerických výpočtoch, kedy je aspoň jedna iterácia nevyhnutná. V našom prípade sa jedná o výpočet približnej hodnoty Eulerového čísla. V prvom priblížení položíme hodnotu e rovnú jednej rovnako, ako hodnotu prírastku epsilon. Za upozornenie stojí dátový typ long double, a teda aj odpovedajúce vhodné určenie typov číselných konštánt. Aj vo formátovanom výstupe sme museli špecifikovať príslušný dátový typ. Operátory priradenia spojené s operáciou nad svojou ľavou stranou sú použité skôr pre pripomenutie ich existencie. /* subor dowhile2.c */ #include <stdio.h> #include <math.h> #define chyba 1.0e-15L int main(void) long double e = 1.0L, epsilon = 1.0L; unsigned long n = 0L; printf("\n"); do epsilon /= ++n; e += epsilon; while (epsilon > chyba); printf("e=%21.18lf\tpocet iteracii:%ld", e, n); return 0;

14 6.8. Príkaz skoku Príkaz skoku patrí k zatracovaným príkazom štruktúrovaného programovania. Skutočne s jeho pomocou dokáže menej skúsený programátor vytvoriť zdrojový text, pre ktorý sa vžilo označenie špagetový. Skutočnosť, že sme si príkaz skoku nezatajili má tri príčiny: 1. Jazyk C proste príkaz skoku obsahuje. Jeho neuvedenie by nebolo fér. 2. Jazyk C umožňuje ako systémový prostriedok písať programy na veľmi nízkej úrovni. Často veľmi blízke strojovému kódu. Použitie skoku v takom prípade môže byť veľmi žiaduce. 3. Skokové príkazy break, continue a return sú označované ako štruktúrované skoky. Ich použitie teórie (ani praxe) programovanie neodmieta. Zostáva nám teda len príkaz skoku goto. Jeho syntax je jednoduchá: identifier: <statement> ; goto <identifier> ; Uviedli sme si nielen syntax goto samotného, ale aj súvisiaceho návestia identifier. Návestie neprevádza žiadnu akciu a nemá iný vplyv na riadenie behu. Jeho identifikátor len označuje nejaké miesto v zdrojovom texte. Príkaz goto prenáša riadenie na príkaz, označený návestím. V rámci jednej funkcie nesmú byť dva rovnaké návestia. Predchádzajúca kapitola Obsah Začiatok Nasledujúca kapitola