6. díl - Cykly v C++ (for)

C a C++ C++ Základní konstrukce C++ Cykly v C++ (for)

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 C++, jsme si vysvětlili podmínky. Nyní přejdeme k cyklům. Po dnešním C++ 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ívá 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 (deklarace; podminka; aktualizace)
        prikaz;
  • deklarace - Zde deklarujeme řídící proměnnou 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říklad můžeme napsat for (int i = 0; ...). Samozřejmě si můžeme proměnnou i vytvořit někde nad tím a již nemusíme psát slovíčko int, bývá ale zvykem používat právě int i.
  • podmínka - je podmínka vykonání dalšího kroku cyklu. Jakmile přestane platit, cyklus se ukončí. Podmínka může být např i < 10.
  • aktualizace - Zde měníme hodnotu řídící proměnné. Tato část proběhne na konci každého kroku. Zde využijeme speciálních operátorů ++ 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. Operátory ++ a -- můžeme psát jak před proměnnou tak za ní, rozdíl postřehneme když budeme změněnou hodnotu přiřazovat do proměnné. i++ (resp. i--) vrací hodnotu před změnou a ;++i` (resp. --i) vrací hodnotu po změně.
int i = 4;
int a = i++; // vrací hodnotu před přičtením
// a = 4, i = 5
int b = ++i; // vrací hodnotu po přičtení
// b = 5, i = 5

Pozn.: kteroukoli část v závorce cyklu for smíme vynechat, vždy v ní ale musí být alespoň 2 středníky. Pokud vynecháme podmínku, bude se cyklus chovat jako by vždy platila.

Pojďme si udělat jednoduchý příklad, většina z vá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:

cout << "Knock" << endl;
cout << "Knock" << endl;
cout << "Knock" << endl;
cout << "Penny!" << endl;
cin.get();

My ale nemusíme již nic otrocky opisovat:

for (int i = 0; i < 3; i++)
        cout << "Knock" << endl;
cout << "Penny!" << endl;
cin.get();

Výsledek:

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 psaní 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. Příkaz 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 (zvyšuje o 1). Vypišme si čísla od jedné do deseti. Protože nebudeme chtít, aby se nám v konzoli text vždy odřádkoval, nezakončíme řádek s výpisem << endl, ale pouze mezerou:

for (int i = 1; i <= 10; i++)
        cout << i << ' ';
cin.get();

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 na 1 a koncovou na 10.

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:

cout << "Mala nasobilka pomoci cyklu:" << endl;
for (int i = 1; i <= 10; i++)
        cout << i << ' ';
cout << endl;
for (int i = 1; i <= 10; i++)
        cout << i * 2 << ' ';
cout << endl;
for (int i = 1; i <= 10; i++)
        cout << i * 3 << ' ';
cout << endl;
for (int i = 1; i <= 10; i++)
        cout << i * 4 << ' ';
cout << endl;
for (int i = 1; i <= 10; i++)
        cout << i * 5 << ' ';
cout << endl;
for (int i = 1; i <= 10; i++)
        cout << i * 6 << ' ';
cout << endl;
for (int i = 1; i <= 10; i++)
        cout << i * 7 << ' ';
cout << endl;
for (int i = 1; i <= 10; i++)
        cout << i * 8 << ' ';
cout << endl;
for (int i = 1; i <= 10; i++)
        cout << i * 9 << ' ';
cout << endl;
for (int i = 1; i <= 10; i++)
        cout << i * 10 << ' ';
cout << endl;
cin.get();

Výsledek:

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:

cout << "Mala nasobilka pomoci dvou cyklu:" << endl;
for (int j = 1; j <= 10; j++)
{
        for (int i = 1; i <= 10; i++)
                cout << i * j << ' ';
        cout << endl;
}
cin.get();

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á cout << endl.

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:

cout << "Mocninator" << endl;
cout << "==========" << endl;
cout << "Zadejte zaklad mocniny: " << endl;
int a, n; // vytvoříme 2 proměnné naráz
cin >> a;
cout << "Zadejte exponent: " << endl;
cin >> n;

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

cout << "Vysledek: " << vysledek << endl;
cout << "Dekuji za pouziti mocninatoru" << endl;
cin.get();cin.get();

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:
10
Vysledek: 1024
Dekuji za pouziti mocninatoru

Již tušíme, k čemu se for cyklus využívá. Zapamatujme si, že je počet opakování pevně daný, i když jej lze teoreticky napsat i aby toto nesplňoval. 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ě
for (int i = 1; i <= 10; i++)
        i = 1;
cin.get();

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čí. Okno programu zavřeme nebo použijeme tlačítko "Stop" v lište Visual Studia.

Ve for cyklu můžeme samozřejmě mít více proměnných (oddělených čárkou), pokud je ale chceme vytvořit (deklarovat), musí být stejného typu.

Stejně tak místo i++ můžeme použít jiný příkaz a klidně i více příkazů oddělených čárkami.

Tento kód je tedy správně a po jeho skončení bude v proměnné f 10. mocnina 2 (210).

int i;
float f;
for (i = 0, f = 1; i < 10; f *= 2, i++) ;

Pokud bychom chtěli proměnné vytvořit "v cyklu", musí být stejného typu:

for (int i = 0, f = 1; i < 10; f *= 2, i++) ;

Další typy cyklů si vysvětlíme v příští lekci, Cykly v C++ (while, do while).


 

Stáhnout

Staženo 181x (7.1 kB)
Aplikace je včetně zdrojových kódů v jazyce C++

 

 

Článek pro vás napsal Zdeněk Pavlátka
Avatar
Jak se ti líbí článek?
9 hlasů
Autor se věnuje spoustě zajímavých věcí :)
Miniatura
Předchozí článek
Podmínky (větvení) v C++
Miniatura
Všechny články v sekci
Základní konstrukce jazyka C++
Miniatura
Následující článek
Cykly v C++ (while, do while)
Aktivity (10)

 

 

Komentáře

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.

Zatím nikdo nevložil komentář - buď první!