Letní akce! Lákají tě IT školení C#, Javy a PHP v Brně? Přihlas se a napiš nám do zpráv kód "BRNO 500" pro slevu 500 Kč na libovolný brněnský kurz. Lze kombinovat se slevami uvedenými u školení i použít pro více kurzů. Akce končí 28.7.

Lekce 6 - Cykly v Céčku

C a C++ Céčko Základní konstrukce C Cykly v Céčku

ONEbit hosting Unicorn College Tento obsah je dostupný zdarma v rámci projektu IT lidem. Vydávání, hosting a aktualizace umožňují jeho sponzoři.

V minulé lekci, Podmínky (větvení) v jazyce C, jsme si vysvětlili podmínky. Nyní přejdeme k cyklům. Po dnešním tutoriálu již budeme mít téměř kompletní výbavu základních konstrukcí a budeme schopni tvořit rozumné aplikace.

Cykly

Jak již slovo cyklus napoví, něco se bude opakovat. Když chceme v programu něco udělat 100x, jistě nebudeme psát pod sebe 100x ten samý kód, ale vložíme ho do cyklu. Cyklů máme několik druhů, vysvětlíme si, kdy který použít. Samozřejmě si ukážeme praktické příklady.

FOR cyklus

Tento cyklus má stanovený pevný počet opakování a hlavně obsahuje tzv. řídící proměnnou (celočíselnou), ve které se postupně během běhu cyklu mění hodnoty. Syntaxe (zápis) cyklu for je následující:

for (promenna; podminka; prikaz)
  • promenna je řídící proměnná cyklu, které nastavíme počáteční hodnotu (nejčastěji 0, protože v programování vše začíná od nuly, nikoli od jedničky). Např. tedy i = 0. V Céčku si musíme proměnnou i vytvořit někde nad tím.
  • podminka je podmínka vykonání dalšího kroku cyklu. Jakmile nebude platit, cyklus se ukončí. Podmínka může být např. i < 10.
  • prikaz nám říká co se má v každém kroku s řídící proměnnou stát. Tedy zda se má zvýšit nebo snížit. K tomu využijeme speciálních příkazů ++ a --, ty samozřejmě můžete používat i úplně běžně mimo cyklus, slouží ke zvýšení nebo snížení proměnné o 1.

Pojďme si udělat jednoduchý příklad, většina z nás jistě zná Sheldona z The Big Bang Theory. Pro ty co ne, budeme simulovat situaci, kdy klepe na dveře své sousedky. Vždy 3x zaklepe a poté zavolá: "Penny!". Náš kód by bez cyklů vypadal takto:

printf("Knock \n");
printf("Knock \n");
printf("Knock \n");
printf("Penny! \n");

My ale už nic nemusíme otrocky opisovat:

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

Konzolová aplikace
Knock!
Knock!
Knock!
Penny!

Cyklus proběhne 3x, zpočátku je v proměnné i nula, cyklus vypíše "Knock" a zvýší proměnnou i o jedna. Poté běží stejně s jedničkou a dvojkou. Jakmile je v i trojka, již nesouhlasí podmínka i < 3 a cyklus končí. O vynechávání složených závorek platí to samé, co u podmínek. V tomto případě tam nemusí být, protože cyklus spouští pouze jediný příkaz. Nyní můžeme místo trojky napsat do deklarace cyklu desítku. Slovo se vypíše 10x aniž bychom psali něco navíc. Určitě vidíte, že cykly jsou mocným nástrojem.

Zkusme si nyní využít toho, že se nám proměnná inkrementuje. Vypišme si čísla od jedné do deseti a za každým mezeru.

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

Vidíme, že řídící proměnná má opravdu v každé iteraci (průběhu) jinou hodnotu. Všimněte si, že v cyklu tentokrát nezačínáme na nule, ale můžeme nastavit počáteční hodnotu 1 a koncovou 10. V programování je ovšem zvykem začínat od nuly, později zjistíme proč.

Nyní si vypíšeme malou násobilku (násobky čísel 1 až 10, vždy do deseti). Stačí nám udělat cyklus od 1 do 10 a proměnnou vždy násobit daným číslem. Mohlo by to vypadat asi takto:

int i;
printf("Mala nasobilka pomoci 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");

Konzolová aplikace
Mala nasobilka pomoci 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 hezky, ale pořád jsme toho dost napsali. Pokud vás napadlo, že v podstatě děláme 10x to samé a pouze zvyšujeme číslo, kterým násobíme, máte pravdu. Nic nám nebrání vložit 2 cykly do sebe:

int j;
int i;
printf("Mala nasobilka pomoci dvou cyklu: \n");
for (j = 1; j <= 10; j++)
{
        for (i = 1; i <= 10; i++)
                printf("%d ", i * j);
        printf("\n");
}

Poměrně zásadní rozdíl, že? Pochopitelně nemůžeme použít u obou cyklů i, protože jsou vložené do sebe. Proměnná j nabývá ve vnějším cyklu hodnoty 1 až 10. V každé iteraci (rozumějte průběhu) cyklu je poté spuštěn další cyklus s proměnnou i. Ten je nám již známý, vypíše násobky, v tomto případě násobíme proměnnou j. Po každém běhu vnitřního cyklu je třeba odřádkovat, to vykoná printf("\n").

Udělejme si ještě jeden program, na kterém si ukážeme práci s vnější proměnnou. Aplikace bude umět spočítat libovolnou mocninu libovolného čísla:

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

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

printf("Vysledek: %d\n", vysledek);
printf("Dekuji za pouziti mocninatoru \n");

Asi všichni tušíme, jak funguje mocnina. Pro jistotu připomenu, že například 23 = 2 * 2 * 2. Tedy an spočítáme tak, že n-1 krát vynásobíme číslo a číslem a. Výsledek si samozřejmě musíme ukládat do proměnné. Zpočátku bude mít hodnotu a a postupně se bude v cyklu pronásobovat. Pokud jste to nestihli, máme tu samozřejmě článek s algoritmem výpočtu libovolné mocniny. Vidíme, že naše proměnná vysledek je v těle cyklu normálně přístupná. Pokud si však nějakou proměnnou založíme v těle cyklu, po skončení cyklu zanikne a již nebude přístupná.

Konzolová aplikace
Mocninator
==========
Zadejte zaklad mocniny:
2
Zadejte exponent:
8
Vysledek: 256
Dekuji za pouziti mocninatoru

Již tušíme, k čemu se for cyklus využívá. Zapamatujme si, že je počet opakování pevně daný. Do proměnné cyklu bychom neměli nijak zasahovat ani dosazovat, program by se mohl tzv. zacyklit, zkusme si ještě poslední, odstrašující příklad:

// tento kód je špatně
int i;
for (i = 1; i <= 10; i++)
        i = 1;

Au, vidíme, že program se zasekl. Cyklus stále inkrementuje proměnnou i, ale ta se vždy sníží na 1. Nikdy tedy nedosáhne hodnoty > 10, cyklus nikdy neskončí. Program zastavíme tlačítkem "Stop" u okna konzole.

While cyklus

While cyklus funguje jinak, jednoduše opakuje příkazy v bloku dokud platí podmínka. Syntaxe cyklu je následující:

while (podminka)
{
        // příkazy
}

Pokud vás napadá, že lze přes while cyklus udělat i for cyklus, máte pravdu :) For je vlastně speciální případ while cyklu. While se ale používá na trochu jiné věci, často máme v jeho podmínce např. metodu vracející logickou hodnotu true/false. Původní příklad z for cyklu bychom udělali následovně pomocí while:

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

To ale není ideální použití while cyklu. Vezmeme si naši kalkulačku z minulých lekcí a opět ji trochu vylepšíme, konkrétně o možnost zadat více příkladů. Program tedy hned neskončí, ale zeptá se uživatele, zda si přeje spočítat další příklad. Připomeňme si původní verzi kódu (je to ta verze se switchem, ale klidně použijte i tu bez něj, záleží na vás):

double a;
double b;
int volba; // Mohli bychom použít char, abychom zbytečně nepoužívali moc místa
double vysledek;
printf("Vitejte v kalkulacce \n");
printf("Zadejte prvni cislo: \n");
scanf("%lf", &a);
printf("Zadejte druhe cislo: \n");
scanf("%lf", &b);
printf("Zvolte si operaci: \n");
printf("1 - scitani \n");
printf("2 - odcitani \n");
printf("3 - nasobeni \n");
printf("4 - deleni \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("Vysledek: %lf\n", vysledek);
else
        printf("Neplatna volba \n");
printf("\n");
printf("Dekuji za pouziti kalkulacky");

Nyní vložíme téměř celý kód do while cyklu. Naší podmínkou bude, že uživatel zadá "1", budeme tedy kontrolovat obsah proměnné pokracovat. Zpočátku bude tato proměnná nastavena na "1", aby se program vůbec spustil, poté do ní necháme načíst volbu uživatele:

double a;
double b;
int volba; // Mohli bychom použít char, abychom zbytečně nepoužívali moc místa
double vysledek;
char pokracovat = 1;
printf("Vitejte v kalkulacce \n");
while (pokracovat == 1)
{
        printf("Zadejte prvni cislo: \n");
        scanf("%lf", &a);
        printf("Zadejte druhe cislo: \n");
        scanf("%lf", &b);
        printf("Zvolte si operaci: \n");
        printf("1 - scitani \n");
        printf("2 - odcitani \n");
        printf("3 - nasobeni \n");
        printf("4 - deleni \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("Vysledek: %lf\n", vysledek);
        else
                printf("Neplatna volba \n");
        printf("Prejete si zadat dalsi priklad? [1/0]");
        scanf("%d",  &pokracovat);
}
printf("Dekuji za pouziti kalkulacky");

Výsledek:

Konzolová aplikace
Vitejte v kalkulacce
Zadejte prvni cislo:
10
Zadejte druhe cislo:
20
Zvolte si operaci:
1 - scitani
2 - odcitani
3 - nasobeni
4 - deleni
1
Vysledek: 30.000000
Prejete si zadat dalsi priklad? [1/0]1
Zadejte prvni cislo:
50
Zadejte druhe cislo:
20
Zvolte si operaci:
1 - scitani
2 - odcitani
3 - nasobeni
4 - deleni
2
Vysledek: 30.000000
Prejete si zadat dalsi priklad? [1/0]0
Dekuji za pouziti kalkulacky

Do-while cyklus

Posledním typem cyklu je do while. Je téměř stejný jako while, ale kontrolní podmínka je umístěna až na konec cyklu. Máme tedy jistotu, že minimálně jednou cyklus vždy proběhne. Pro ukázku si ještě přepíšeme naši kalkulačku tak, aby používala do while. Všimněme si, že nyní není potřeba nastavovat hodnotu pokracovat před počátkem cyklu, hodnota se nastaví až v samostném cyklu.

double a;
double b;
int volba; // Mohli bychom použít char, abychom zbytečně nepoužívali moc místa
double vysledek;
char pokracovat; //neni potreba nastavovat
printf("Vitejte v kalkulacce \n");
do
{
        printf("Zadejte prvni cislo: \n");
        scanf("%lf", &a);
        printf("Zadejte druhe cislo: \n");
        scanf("%lf", &b);
        printf("Zvolte si operaci: \n");
        printf("1 - scitani \n");
        printf("2 - odcitani \n");
        printf("3 - nasobeni \n");
        printf("4 - deleni \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("Vysledek: %lf\n", vysledek);
        else
                printf("Neplatna volba \n");
        printf("Prejete si zadat dalsi priklad? [1/0]");
        scanf("%d",  &pokracovat);
} while (pokracovat == 1);
printf("Dekuji za pouziti kalkulacky");

Cyklus do while není tak běžný jako předchozí dva cykly, ale v některých situacích je vhodnější.

Naši aplikaci lze nyní používat vícekrát a je již téměř hotová. Příště si ukážeme práci s poli.

S cykly se toho dá dělat mnohem více a dozvíte se to v dalších sekcích našeho kurzu, nemyslíme si, že je vhodné zasypávat vás přemírou syntaxe na úplném začátku. Více si o nich povíme až v článku Pokročilé cykly v jazyce C, na který narazíte znovu během kurzu.

Již toho umíme docela dost, začíná to být zábava, že? :) V příští lekci, Pole v jazyce C, se budeme věnovat polím.


 

Stáhnout

Staženo 229x (95.44 kB)

 

 

Článek pro vás napsal Samuel Kodytek
Avatar
Jak se ti líbí článek?
5 hlasů
Autor se věnuje Javě, Kotlinu, PHP, C, HTML. Zajímá ho spíše game design.
Miniatura
Předchozí článek
Podmínky (větvení) v jazyce C
Miniatura
Všechny články v sekci
Základní konstrukce jazyka C
Miniatura
Následující článek
Cvičení k 6. lekci Céčka
Aktivity (11)

 

 

Komentáře
Zobrazit starší komentáře (36)

Avatar
DarkCoder
Člen
Avatar
DarkCoder:9.11.2017 23:24

Ano, má samozřejmě svá omezení. Nic však nebrání nikomu použít jinou alternativu pro konkrétní prostředí (např. NCurses, apod.), popř. si vytvořit svoji vlastní, ale to už si vyžaduje vyšší skill než znalost načítání znaku. Také jsem se díval. Lekce s getchar() je opravdu hodně hluboko zanořená, přitom se jedná o základní konstrukci. Určitě by stálo za to to přesunout do jedné z prvních lekcí základního kurzu.

Odpovědět 9.11.2017 23:24
"„Učíš-li se proto, aby sis zapamatoval, zapomeneš. Učíš-li se proto, abys porozuměl, zapamatuješ si."
Avatar
Tomas Bahensky:19. února 11:42

Cau, mam jeden dotaz k "Mocninatoru" Je nejaky rozdil mezi zapisy podminek viz nize? Vysled se zda byt stejny....

vysledek = f;
    for (h = 1; h < g; h++)
        vysledek = vysledek * f;

a

vysledek = f;
    for (h = 0; h < (g - 1); h++)
        vysledek = vysledek * f;

Diky!

 
Odpovědět 19. února 11:42
Avatar
DarkCoder
Člen
Avatar
Odpovídá na Tomas Bahensky
DarkCoder:19. února 18:13

Výsledek obou úryvků kódu je stejný, jelikož je stejný počet opakování cyklu a řídící proměnné cyklu nemají vliv na příkaz uvnitř tohoto cyklu. První varianta je ale efektivnější, neboť je zapotřebí menší množství strojových instrukcí pro řízení programu než u druhé varianty. Varianta, kde řídící proměnná je inicializována na nulu, se používá zejména u polí. Důvodem je, že první prvek pole je pole s nulovým indexem.

Odpovědět 19. února 18:13
"„Učíš-li se proto, aby sis zapamatoval, zapomeneš. Učíš-li se proto, abys porozuměl, zapamatuješ si."
Avatar
Odpovídá na DarkCoder
Tomas Bahensky:19. února 20:10

Diky DarkCoder! Rikal jsem si, ze to bude kvuli necemu, o cem v tuto chvili nemam paru :))

 
Odpovědět 19. února 20:10
Avatar
Tomas Bahensky:21. února 17:42

Cau, mam jeste jeden dotaz ohledne DO WHILE. Konkretne jde o prepsani kodu za pouziti WHILE (viz nize) na DO WHILE:

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

Dle infa z teto lekce jsem ho prepsal nasledovne:

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

A moje otazka zni:

  • Kdyz u DO WHILE nemusime nastavovat vstupni hodnotu promenne, podle ceho si ji program urci? Tento kod mi vypise cisla 2-10, takze vstupni hodnota je 2? Proc?

Je to tim, ze na tento priklad je DO WHILE neaplikovatelny bez urceni vstupni hodnoty promenne?

Diky!
Tomas

 
Odpovědět 21. února 17:42
Avatar
DarkCoder
Člen
Avatar
Odpovídá na Tomas Bahensky
DarkCoder:21. února 20:23

Takovéto přepsání cyklu do-while je chybné. Proměnná i použita jako argument funkce printf() není určena a tudíž úryvek kódu s do-while cyklem postrádá smysluplný výsledek. V příkladu s kalkulačkou počáteční hodnota proměnné pokracovat nemusí být určena. Sice je podmínka cyklu vyhodnocena na jeho konci stejně jako ve tvém přepisu, ale těsně předtím je proměnná pokracovat naplněna pomocí funkce scanf(). Takže se proměnná pokracovat porovnává s konkrétní (určenou) hodnotou a proto je tento kód správně.

Globální proměnné a statické lokální proměnné, které nejsou explicitně inicializovány, jsou automaticky nastaveny na nulu. Ostatní lokální proměnné, které nejsou inicializovány, mohou obsahovat libovolnou neznámou hodnotu. Některé překladače jazyka C mohou nastavovat neinicializované lokální proměnné na nulu, ale na to bych se rozhodně nespoléhal. Použití neurčené globální proměnné je možné ale není považováno za správné.

Odpovědět  +1 21. února 20:23
"„Učíš-li se proto, aby sis zapamatoval, zapomeneš. Učíš-li se proto, abys porozuměl, zapamatuješ si."
Avatar
Rudolf Mak
Člen
Avatar
Rudolf Mak:10. dubna 20:58

Zdravím, chcel by som sa spýtať aký je rozdiel medzi deklarovaním počítadla cyklu pred cyklom a v príkaze cyklu:

for (int i = 0;i<10;i++)
{

}

kedže aj táto forma funguje (aspoň mne).

 
Odpovědět 10. dubna 20:58
Avatar
David Čápka
Tým ITnetwork
Avatar
Odpovídá na Rudolf Mak
David Čápka:10. dubna 21:02

Ahoj, zápis v článku je klasičtější, to co ti funguje jde až od standardu C99, můžeš se podívat jak moc je tato verze rozšířená. Vzpomínám si, že když jsem to řešil, došel jsem k tomu, že budu používat raději ten klasický zápis, ale třeba je dnes již situace jiná. Ve většině případů to je asi jedno.

Odpovědět 10. dubna 21:02
Jsem moc rád, že jsi na síti, a přeji ti top IT kariéru, ať jako zaměstnanec nebo podnikatel. Máš na to! :)
Avatar
Rudolf Mak
Člen
Avatar
Odpovídá na David Čápka
Rudolf Mak:10. dubna 21:25

Ďakujem za odpoveď, myslím že ostanem tiež pri klasickom zápise, kedže je viac podporovaný a rozdiel v zápise je minimálny.

 
Odpovědět 10. dubna 21:25
Avatar
DarkCoder
Člen
Avatar
Odpovídá na Rudolf Mak
DarkCoder:10. dubna 22:03

Deklarací proměnné uvnitř cyklu zpřesňuješ rozsah viditelnosti proměnné. Nejen že deklaruješ proměnnou až tehdy když je třeba a šetříš tak pamětí, ale mnoho překladačů tak může lépe optimalizovat tvůj zdrojový kód. Drobnou nevýhodou je podpora od standardu C99, což už ale kvalitní překladače mají a čitelnost programu. Deklarace proměnných na začátku funkce či bloku je mnohem pohodlnější.

Odpovědět 10. dubna 22:03
"„Učíš-li se proto, aby sis zapamatoval, zapomeneš. Učíš-li se proto, abys porozuměl, zapamatuješ si."
Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zobrazeno 10 zpráv z 46. Zobrazit vše