6. diel - Cykly v C #
V predchádzajúcom cvičení, Riešené úlohy k 5. lekcii C # .NET, sme si precvičili získané skúsenosti z predchádzajúcich lekcií.
V minulej lekcii, Riešené úlohy k 5. lekcii C # .NET , sme si vysvetlili podmienky. Teraz prejdeme k cyklom, po dnešnom C # .NET 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 (premenna; podmienka; prikaz)
promenna
je riadiaca premenná cyklu, ktoré nastavíme počiatočnú hodnotu (najčastejšie0
, pretože v programovaní všetko začína od nuly, nie od jednotky). Napr. tedaint i = 0
. Samozrejme si môžeme premennú aj vytvoriť niekde nad tým a už nemusíme písať slovíčkoint
, býva ale zvykom používať práveint i
.podminka
je podmienka vykonanie ďalšieho kroku cyklu. Akonáhle nebude platiť, cyklus sa ukončí. Podmienka môže byť napr `(iprikaz
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 operátorov++
a--
, tie samozrejme môžete používať aj úplne bežne mimo cyklus, slúži na zvýšenie alebo zníženie premenné o1
.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:
{CSHARP_CONSOLE}
Console.WriteLine("Knock");
Console.WriteLine("Knock");
Console.WriteLine("Knock");
Console.WriteLine("Penny!");
Console.ReadKey();
{/CSHARP_CONSOLE}
My ale už nič nemusíme otrocky opisovať:
{CSHARP_CONSOLE}
for (int i=0; i < 3; i++)
{
Console.WriteLine("Knock");
}
Console.WriteLine("Penny!");
Console.ReadKey();
{/CSHARP_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
Skúsme si teraz využiť to, že sa nám premenná inkrementuje. Vypíšme
si čísla od jednej do desať. Pretože nebudeme chcieť, aby sa nám v konzole
text vždy odřádkoval, použijeme miesto WriteLine()
iba
Write()
.
{CSHARP_CONSOLE}
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i);
Console.ReadKey();
{/CSHARP_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:
{CSHARP_CONSOLE}
Console.WriteLine("Malá násobilka pomocou cyklu:");
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 2);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 3);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 4);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 5);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 6);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 7);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 8);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 9);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 10);
Console.ReadKey();
{/CSHARP_CONSOLE}
Konzolová aplikácia
Malá násobilka pomocou 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:
{CSHARP_CONSOLE}
Console.WriteLine("Malá násobilka pomocou dvoch cyklov:");
for (int j = 1; j <= 10; j++)
{
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * j);
Console.WriteLine();
}
Console.ReadKey();
{/CSHARP_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 hodnôt 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á Console.WriteLine()
. Môžete
si skúsiť vypísané riadky upravená pomocou metódy PadLeft()
tak, aby boli čísla pekne v stĺpcoch.
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:
{CSHARP_CONSOLE}
Console.WriteLine("Mocninátor");
Console.WriteLine("==========");
Console.WriteLine("Zadajte základ mocniny: ");
int a = int.Parse(Console.ReadLine());
Console.WriteLine("Zadajte exponent: ");
int n = int.Parse(Console.ReadLine());
int vysledek = a;
for (int i = 0; i < (n - 1); i++)
vysledek = vysledek * a;
Console.WriteLine("Výsledok: {0}", vysledek);
Console.WriteLine("Ďakujem za použitia mocninátoru");
Console.ReadKey();
{/CSHARP_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
Mocninátor
==========
Zadajte základ mocniny:
2
Zadajte exponent:
3
Výsledok: 8
Ďakujem za použitia mocninátoru
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:
{CSHARP_CONSOLE}
// tento kód je zle
for (int i = 1; i <= 10; i++)
i = 1;
Console.ReadKey();
{/CSHARP_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čí. Okno
programu zatvoríme alebo použijeme tlačidlo Stop v lište Visual Studia .
While cyklus
Cyklus while
funguje inak, jednoducho opakuje príkazy v bloku
kým platí podmienka. Syntax cyklu je nasledovné:
while (podmienka) { // 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
cyklu. 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 pomocou while
nasledovne:
{CSHARP_CONSOLE}
int i = 1;
while (i <= 10)
{
Console.Write("{0} ", i);
i++;
}
Console.ReadKey();
{/CSHARP_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
em, ale pokojne
použite aj tú bez neho, záleží na vás):
{CSHARP_CONSOLE}
Console.WriteLine("Vitajte v kalkulačke");
Console.WriteLine("Zadajte prvé číslo:");
float a = float.Parse(Console.ReadLine());
Console.WriteLine("Zadajte druhé číslo:");
float b = float.Parse(Console.ReadLine());
Console.WriteLine("Zvoľte si operáciu:");
Console.WriteLine("1 - sčítanie");
Console.WriteLine("2 - odčítanie");
Console.WriteLine("3 - násobenie");
Console.WriteLine("4 - delenie");
int volba = int.Parse(Console.ReadLine());
float vysledek = 0;
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))
Console.WriteLine("Výsledok: {0}", vysledek);
else
Console.WriteLine("Neplatná voľba");
Console.WriteLine("Ďakujem za použitia kalkulačky, aplikáciu ukončíte ľubovoľnou klávesou.");
Console.ReadKey();
{/CSHARP_CONSOLE}
Teraz vložíme takmer celý kód do while
cyklu. Našou
podmienkou bude, že používateľ zadá "áno", budeme teda kontrolovať obsah
premennej pokracovat
. Spočiatku bude táto premenná nastavená
na "áno", aby sa program vôbec spustil, potom do nej necháme načítať
voľbu užívateľa:
Console.WriteLine("Vitajte v kalkulačke"); string pokracovat = "áno"; while (pokracovat == "áno") { Console.WriteLine("Zadajte prvé číslo:"); float a = float.Parse(Console.ReadLine()); Console.WriteLine("Zadajte druhé číslo:"); float b = float.Parse(Console.ReadLine()); Console.WriteLine("Zvoľte si operáciu:"); Console.WriteLine("1 - sčítanie"); Console.WriteLine("2 - odčítanie"); Console.WriteLine("3 - násobenie"); Console.WriteLine("4 - delenie"); int volba = int.Parse(Console.ReadLine()); float vysledek = 0; 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)) Console.WriteLine("Výsledok: {0}", vysledek); else Console.WriteLine("Neplatná voľba"); Console.WriteLine("Prajete si zadať ďalší príklad? [áno / nie]"); pokracovat = Console.ReadLine(); } Console.WriteLine("Ďakujem za použitia kalkulačky, aplikáciu ukončíte ľubovoľnou klávesou."); Console.ReadKey();
Konzolová aplikácia
Vitajte v kalkulačke
Zadajte prvé číslo:
12
Zadajte druhé číslo:
128
Zvoľte si operáciu:
1 - sčítanie
2 - odčítanie
3 - násobenie
4 - delenie
1
Výsledok: 140
Prajete si zadať ďalší príklad? [áno / nie]
áno
Zadajte prvé číslo:
-10,5
Zadajte druhé číslo:
Naši aplikáciu možno teraz používať viackrát a je už takmer hotová. V budúcej lekcii, Riešené úlohy k 6. lekcii C # .NET , si ukážeme, ako zabezpečiť všetky vstupy od užívateľa.
Už toho vieme celkom dosť, začína to byť zábava, že?
V nasledujúcom cvičení, Riešené úlohy k 6. lekcii C # .NET, si precvičíme nadobudnuté skúsenosti z predchádzajúcich lekcií.
Mal si s čímkoľvek problém? Stiahni si vzorovú aplikáciu nižšie a porovnaj ju so svojím projektom, chybu tak ľahko nájdeš.
Stiahnuť
Stiahnutím nasledujúceho súboru súhlasíš s licenčnými podmienkami
Stiahnuté 1295x (90.66 kB)
Aplikácia je vrátane zdrojových kódov v jazyku C#