6. diel - Cykly v céčko

V predchádzajúcom cvičení, Riešené úlohy k 4.-5. lekciu Céčka, sme si precvičili získané skúsenosti z predchádzajúcich lekcií.

V minulej lekcii, Riešené úlohy k 4.-5. lekciu Céčka , sme si vysvetlili podmienky. Teraz prejdeme k cyklom. Po dnešnom tutoriálu už budeme mať takmer kompletnú výbavu základných konštrukcií a budeme schopní tvoriť rozumné aplikácie.

Cykly

Ako už slovo cyklus napovie, niečo sa bude opakovať. Keď chceme v programe niečo urobiť 100x, určite nebudeme písať pod seba 100x ten istý kód, ale vložíme ho do cyklu. Cyklov máme niekoľko druhov, vysvetlíme si, kedy ktorý použiť. Samozrejme si ukážeme praktické príklady.

For cyklus

Tento cyklus má stanovený pevný počet opakovaní a hlavne obsahuje tzv. Riadiace premennú (celočíselnú), v ktorej sa postupne počas behu cyklu menia hodnoty. Syntax (zápis) cyklu for je nasledovná:

for (promenna; podminka; prikaz)

• promenna je riadiaca premenná cyklu, ktoré nastavíme počiatočnú hodnotu (najčastejšie 0, pretože v programovaní všetko začína od nuly, nie od jednotky). Napr. teda i = 0. V céčko si musíme premennú i vytvoriť niekde nad tým.
• podminka je podmienka vykonanie ďalšieho kroku cyklu. Akonáhle nebude platiť, cyklus sa ukončí. Podmienka môže byť napr. i < 10.
• prikaz nám hovorí čo sa má v každom kroku s riadiacou premennou stáť. Teda či sa má zvýšiť alebo znížiť. K tomu využijeme špeciálnych príkazov ++ a --, tie samozrejme môžete používať aj úplne bežne mimo cyklus, slúži na zvýšenie alebo zníženie premenné o 1.

Poďme si urobiť jednoduchý príklad, väčšina z nás určite pozná Sheldona z The Big Bang Theory. Pre tých čo nie, budeme simulovať situáciu, kedy klope na dvere svojej susedky. Vždy 3x zaklope a potom zavolá: "Penny!". Náš kód by bez cyklov vyzeral takto:

{C_CONSOLE}
printf("Knock \n");
printf("Knock \n");
printf("Knock \n");
printf("Penny! \n");
{/C_CONSOLE}

My ale už nič nemusíme otrocky opisovať:

{C_CONSOLE}
int i;
for (i = 0; i < 3; i++)
{
    printf("Knock! \n");
}
printf("Penny! \n");
{/C_CONSOLE}

Konzolová aplikácia
Knock!
Knock!
Knock!
Penny!

Cyklus prebehne 3x, spočiatku je v premennej i nula, cyklus vypíše "Knock" a zvýši premennú i o jedna. Potom beží rovnako s jednotkou a dvojkou. Akonáhle je v i trojka, už nesúhlasí podmienka i < 3 a cyklus končí. O vynechávanie zložených zátvoriek platí to isté, čo u podmienok. V tomto prípade tam nemusí byť, pretože cyklus spúšťa iba jediný príkaz. Teraz môžeme miesto trojky napísať do deklarácie cyklu desiatku. Slovo sa vypíše 10x bez toho aby sme písali niečo navyše. Určite vidíte, že cykly sú mocným nástrojom.

Skúsme si teraz využiť to, že sa nám premenná inkrementuje. Vypíšme si čísla od jednej do desať a za každým medzeru.

{C_CONSOLE}
int i;
for (i = 1; i <= 10; i++)
    printf("%d ", i);
{/C_CONSOLE}

Vidíme, že riadiaci premenná má naozaj v každej iterácii (priebehu) inú hodnotu. Všimnite si, že v cykle tentoraz nezačíname na nule, ale môžeme nastaviť počiatočnú hodnotu 1 a koncovú 10. V programovaní je však zvykom začínať od nuly, neskôr zistíme prečo.

Teraz si vypíšeme malú násobilku (násobky čísel 1 až 10, vždy do desať). Stačí nám urobiť cyklus od 1 do 10 a premennú vždy násobiť daným číslom. Mohlo by to vyzerať asi takto:

{C_CONSOLE}
int i;
printf("Malička nasobilka pomôcť cyklu: \n");
for (i = 1; i <= 10; i++)
    printf("%d ", i);
printf("\n");
for (i = 1; i <= 10; i++)
    printf("%d ", i * 2);
printf("\n");
for (i = 1; i <= 10; i++)
    printf("%d ", i * 3);
printf("\n");
for (i = 1; i <= 10; i++)
    printf("%d ", i * 4);
printf("\n");
for (i = 1; i <= 10; i++)
    printf("%d ", i * 5);
printf("\n");
for (i = 1; i <= 10; i++)
    printf("%d ", i * 6);
printf("\n");
for (i = 1; i <= 10; i++)
    printf("%d ", i * 7);
printf("\n");
for (i = 1; i <= 10; i++)
    printf("%d ", i * 8);
printf("\n");
for (i = 1; i <= 10; i++)
    printf("%d ", i * 9);
printf("\n");
for (i = 1; i <= 10; i++)
    printf("%d ", i * 10);
printf("\n");
{/C_CONSOLE}

Konzolová aplikácia
Malička nasobilka pomôcť cyklu:
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100

Program funguje pekne, ale stále sme toho dosť napísali. Ak vás napadlo, že v podstate robíme 10x to isté a len zvyšujeme číslo, ktorým násobíme, máte pravdu. Nič nám nebráni vložiť 2 cykly do seba:

{C_CONSOLE}
int j;
int i;
printf("Malička nasobilka pomôcť dvoch cyklu: \n");
for (j = 1; j <= 10; j++)
{
    for (i = 1; i <= 10; i++)
        printf("%d ", i * j);
    printf("\n");
}
{/C_CONSOLE}

Pomerne zásadný rozdiel, že? Pochopiteľne nemôžeme použiť u oboch cyklov i, pretože sú vložené do seba. Premenná j nadobúda vo vonkajšom cykle hodnoty 1 až 10. V každej iterácii (rozumejte priebehu) cyklu je potom spustený ďalší cyklus s premennou i. Ten je nám už známy, vypíše násobky, v tomto prípade násobíme premennú j. Po každom behu vnútorného cyklu treba odřádkovat, to vykoná printf("\n").

Urobme si ešte jeden program, na ktorom si ukážeme prácu s vonkajšou premennou. Aplikácia bude vedieť spočítať ľubovoľnú mocninu ľubovoľného čísla:

{C_CONSOLE}
int i;
int a;
int n;
int vysledek;
printf("Mocninator \n");
printf("========== \n");
printf("Zadajte zaklad mocniny: \n");
scanf("%d", &a);
printf("Zadajte exponent: \n");
scanf("%d", &n);

vysledek = a;
for (i = 0; i < (n - 1); i++)
    vysledek = vysledek * a;

printf("Vysledok: %d\n", vysledek);
printf("Dekuji za pouziti mocninatoru \n");
{/C_CONSOLE}

Asi všetci tušíme, ako funguje mocnina. Pre istotu pripomeniem, že napríklad 2^3 = 2 * 2 * 2. Teda a^n spočítame tak, že n-1 krát vynásobíme číslo a číslom a. Výsledok si samozrejme musíme ukladať do premennej. Spočiatku bude mať hodnotu a a postupne sa bude v cykle pronásobovat. Ak ste to nestihli, máme tu samozrejme článok s algoritmom výpočtu ľubovoľnej mocniny. Vidíme, že naša premenná vysledek je v tele cyklu normálne prístupná. Ak si však nejakú premennú založíme v tele cyklu, po skončení cyklu zanikne a už nebude prístupná.

Konzolová aplikácia
Mocninator
==========
Zadajte zaklad mocniny:
2
Zadajte exponent:
8
Vysledok: 256
Dekuji za pouziti mocninatoru

Už tušíme, na čo sa for cyklus využíva. Zapamätajme si, že je počet opakovaní pevne daný. Do premennej cyklu by sme nemali nijako zasahovať ani dosadzovať, program by sa mohol tzv. Zacykliť, skúsme si ešte posledný, odstrašujúci príklad:

{C_CONSOLE}
// tento kód je zle
int i;
for (i = 1; i <= 10; i++)
    i = 1;
{/C_CONSOLE}

Au, vidíme, že program sa zasekol. Cyklus stále inkrementuje premennú i, ale tá sa vždy zníži na 1. Nikdy teda nedosiahne hodnoty > 10, cyklus nikdy neskončí. Program zastavíme tlačidlom "Stop" pri okne konzoly.

While cyklus

Cyklus while funguje inak, jednoducho opakuje príkazy v bloku kým platí podmienka. Syntax cyklu je nasledovné:

while (podminka)
{
    // príkazy
}

Ak vás napadá, že možno cez while cyklus urobiť aj for cyklus, máte pravdu . Cyklus for je vlastne špeciálny prípad while. Cyklus while sa ale používa na trochu iné veci, často máme v jeho podmienke napr. Metódu vracajúci logickú hodnotu true / false. Pôvodný príklad z for cyklu by sme urobili nasledovne pomocou while:

{C_CONSOLE}
int i = 1;
while (i <= 10)
{
    printf("%d ", i);
    i++;
}
{/C_CONSOLE}

To ale nie je ideálne použitie while cyklu. Vezmeme si našu kalkulačku z minulých lekcií a opäť ju trochu vylepšíme, konkrétne o možnosť zadať viac príkladov. Program teda hneď neskončí, ale spýta sa užívateľa, či si praje spočítať ďalší príklad. Pripomeňme si pôvodnú verziu kódu (je to tá verzia sa switch, ale pokojne použite aj tú bez neho, záleží na vás):

{C_CONSOLE}
double a;
double b;
int volba; // Mohli by sme použiť char, aby sme zbytočne nepoužívali veľa miesta
double vysledek;
printf("Vitajte v kalkulačke \n");
printf("Zadajte prvni cislo: \n");
scanf("%lf", &a);
printf("Zadajte druhe cislo: \n");
scanf("%lf", &b);
printf("Zvoľte si operáciu: \n");
printf("1 - sčítanie \n");
printf("2 - odčítanie \n");
printf("3 - násobenie \n");
printf("4 - delenie \n");
scanf("%d", &volba);
switch(volba)
{
    case 1:
        vysledek = a + b;
        break;
    case 2:
        vysledek = a - b;
        break;
    case 3:
        vysledek = a * b;
        break;
    case 4:
        vysledek = a / b;
        break;
}
if ((volba > 0) && (volba < 5))
    printf("Vysledok: %lf\n", vysledek);
else
    printf("Neplatný voľba \n");
printf("\n");
printf("Dekuji za použitia kalkulačky");
{/C_CONSOLE}

Teraz vložíme takmer celý kód do while cyklu. Našou podmienkou bude, že používateľ zadá "1", budeme teda kontrolovať obsah premennej pokracovat. Spočiatku bude táto premenná nastavená na "1", aby sa program vôbec spustil, potom do nej necháme načítať voľbu užívateľa:

double a;
double b;
int volba; // Mohli by sme použiť char, aby sme zbytočne nepoužívali veľa miesta
double vysledek;
char pokracovat = 1;
printf("Vitajte v kalkulačke \n");
while (pokracovat == 1)
{
    printf("Zadajte prvni cislo: \n");
    scanf("%lf", &a);
    printf("Zadajte druhe cislo: \n");
    scanf("%lf", &b);
    printf("Zvoľte si operáciu: \n");
    printf("1 - sčítanie \n");
    printf("2 - odčítanie \n");
    printf("3 - násobenie \n");
    printf("4 - delenie \n");
    scanf("%d", &volba);
    switch(volba)
    {
        case 1:
            vysledek = a + b;
            break;
        case 2:
            vysledek = a - b;
            break;
        case 3:
            vysledek = a * b;
            break;
        case 4:
            vysledek = a / b;
            break;
    }
    if ((volba > 0) && (volba < 5))
        printf("Vysledok: %lf\n", vysledek);
    else
        printf("Neplatný voľba \n");
    printf("Prajete si zadať dalsi priklad? [1/0]");
    scanf("%d",  &pokracovat);
}
printf("Dekuji za použitia kalkulačky");

výsledok:

Konzolová aplikácia
Vitajte v kalkulačke
Zadajte prvni cislo:
10
Zadajte druhe cislo:
20
Zvoľte si operáciu:
1 - sčítanie
2 - odčítanie
3 - násobenie
4 - delenie
1
Vysledok: 30.000000
Prajete si zadať dalsi priklad? [1/0]1
Zadajte prvni cislo:
50
Zadajte druhe cislo:
20
Zvoľte si operáciu:
1 - sčítanie
2 - odčítanie
3 - násobenie
4 - delenie
2
Vysledok: 30.000000
Prajete si zadať dalsi priklad? [1/0]0
Dekuji za použitia kalkulačky

Do-while cyklus

Posledným typom cyklu je do while. Je takmer rovnaký ako while, ale kontrolná podmienka je umiestnená až na koniec cyklu. Máme teda istotu, že minimálne raz cyklus vždy prebehne. Pre ukážku si ešte prepíšeme našu kalkulačku tak, aby používala do while. Všimnime si, že teraz nie je potreba nastavovať hodnotu pokracovat pred začiatkom cyklu, hodnota sa nastaví až v samotnom cykle.

double a;
double b;
int volba; // Mohli by sme použiť char, aby sme zbytočne nepoužívali veľa miesta
double vysledek;
char pokracovat; //neni potreba nastavovať
printf("Vitajte v kalkulačke \n");
do
{
    printf("Zadajte prvni cislo: \n");
    scanf("%lf", &a);
    printf("Zadajte druhe cislo: \n");
    scanf("%lf", &b);
    printf("Zvoľte si operáciu: \n");
    printf("1 - sčítanie \n");
    printf("2 - odčítanie \n");
    printf("3 - násobenie \n");
    printf("4 - delenie \n");
    scanf("%d", &volba);
    switch(volba)
    {
        case 1:
            vysledek = a + b;
            break;
        case 2:
            vysledek = a - b;
            break;
        case 3:
            vysledek = a * b;
            break;
        case 4:
            vysledek = a / b;
            break;
    }
    if ((volba > 0) && (volba < 5))
        printf("Vysledok: %lf\n", vysledek);
    else
        printf("Neplatný voľba \n");
    printf("Prajete si zadať dalsi priklad? [1/0]");
    scanf("%d",  &pokracovat);
} while (pokracovat == 1);
printf("Dekuji za použitia kalkulačky");

Cyklus do while nie je tak bežný ako predchádzajúce dva cykly, ale v niektorých situáciách je vhodnejšie.

Naši aplikáciu možno teraz používať viackrát a je už takmer hotová. Nabudúce si ukážeme prácu s poľami.

S cykly sa toho dá robiť oveľa viac a dozviete sa to v ďalších sekciách nášho kurzu, nemyslíme si, že je vhodné zasypávať vás nadmierou syntaxe na úplnom začiatku. Viac si o nich povieme až v článku Pokročilé cykly v jazyku C, na ktorý narazíte znovu počas kurzu.

Už toho vieme celkom dosť, začína to byť zábava, že? V budúcej lekcii, Riešené úlohy k 6. lekcii Céčka , sa budeme venovať poliam.

V nasledujúcom cvičení, Riešené úlohy k 6. lekcii Céčka, si precvičíme nadobudnuté skúsenosti z predchádzajúcich lekcií.