C# týden C# týden
AKCE! Rozšiřujeme naši individuální výuku programování! Čemukoli nerozumíš, nejde ti něco odevzdat? Poradit.
Pouze tento týden sleva až 80 % na C# .NET

Lekce 6 - Cykly v C#

C# .NET Základní konstrukce Cykly v C# American English version English version

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í), jsme si vysvětlili podmínky. Nyní přejdeme k cyklům, po dnešním C#.NET 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 int i = 0. Samozřejmě si můžeme proměnnou i vytvořit někde nad tím a už nemusíme psát slovíčko int, bývá ale zvykem používat právě int i.
  • 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 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.

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:

Console.WriteLine("Knock");
Console.WriteLine("Knock");
Console.WriteLine("Knock");
Console.WriteLine("Penny!");
Console.ReadKey();

My ale už nic nemusíme otrocky opisovat:

for (int i=0; i < 3; i++)
{
    Console.WriteLine("Knock");
}
Console.WriteLine("Penny!");
Console.ReadKey();

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. Příkaz se spustí 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. Protože nebudeme chtít, aby se nám v konzoli text vždy odřádkoval, použijeme místo WriteLine() pouze Write().

for (int i = 1; i <= 10; i++)
    Console.Write("{0} ", i);
Console.ReadKey();

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:

Console.WriteLine("Malá násobilka pomocí 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();

Konzolová aplikace
Malá násobilka pomocí 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:

Console.WriteLine("Malá násobilka pomocí dvou cyklů:");
for (int j = 1; j <= 10; j++)
{
    for (int i = 1; i <= 10; i++)
        Console.Write("{0} ", i * j);
    Console.WriteLine();
}
Console.ReadKey();

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 hodnot 110. 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á Console.WriteLine(). Můžete si zkusit vypsané řádky upravit pomocí metody PadLeft() tak, aby byla čísla hezky ve sloupcích.

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:

Console.WriteLine("Mocninátor");
Console.WriteLine("==========");
Console.WriteLine("Zadejte základ mocniny: ");
int a = int.Parse(Console.ReadLine());
Console.WriteLine("Zadejte exponent: ");
int n = int.Parse(Console.ReadLine());

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

Console.WriteLine("Výsledek: {0}", vysledek);
Console.WriteLine("Děkuji za použití mocninátoru");
Console.ReadKey();

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
Mocninátor
==========
Zadejte základ mocniny:
2
Zadejte exponent:
3
Výsledek: 8
Děkuji za použití mocninátoru

Už 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ě
for (int i = 1; i <= 10; i++)
    i = 1;
Console.ReadKey();

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.

While cyklus

Cyklus while 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 :) Cyklus for je vlastně speciální případ while cyklu. Cyklus 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 pomocí while následovně:

int i = 1;
while (i <= 10)
{
    Console.Write("{0} ", i);
    i++;
}
Console.ReadKey();

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):

Console.WriteLine("Vítejte v kalkulačce");
Console.WriteLine("Zadejte první číslo:");
float a = float.Parse(Console.ReadLine());
Console.WriteLine("Zadejte druhé číslo:");
float b = float.Parse(Console.ReadLine());
Console.WriteLine("Zvolte si operaci:");
Console.WriteLine("1 - sčítání");
Console.WriteLine("2 - odčítání");
Console.WriteLine("3 - násobení");
Console.WriteLine("4 - dělení");
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ýsledek: {0}", vysledek);
else
        Console.WriteLine("Neplatná volba");
Console.WriteLine("Děkuji za použití kalkulačky, aplikaci ukončíte libovolnou klávesou.");
Console.ReadKey();

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

Console.WriteLine("Vítejte v kalkulačce");
string pokracovat = "ano";
while (pokracovat == "ano")
{
    Console.WriteLine("Zadejte první číslo:");
    float a = float.Parse(Console.ReadLine());
    Console.WriteLine("Zadejte druhé číslo:");
    float b = float.Parse(Console.ReadLine());
    Console.WriteLine("Zvolte si operaci:");
    Console.WriteLine("1 - sčítání");
    Console.WriteLine("2 - odčítání");
    Console.WriteLine("3 - násobení");
    Console.WriteLine("4 - dělení");
    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ýsledek: {0}", vysledek);
    else
        Console.WriteLine("Neplatná volba");
    Console.WriteLine("Přejete si zadat další příklad? [ano/ne]");
    pokracovat = Console.ReadLine();
}
Console.WriteLine("Děkuji za použití kalkulačky, aplikaci ukončíte libovolnou klávesou.");
Console.ReadKey();

Konzolová aplikace
Vítejte v kalkulačce
Zadejte první číslo:
12
Zadejte druhé číslo:
128
Zvolte si operaci:
1 - sčítání
2 - odčítání
3 - násobení
4 - dělení
1
Výsledek: 140
Přejete si zadat další příklad? [ano/ne]
ano
Zadejte první číslo:
-10,5
Zadejte druhé číslo:

Naši aplikaci lze nyní používat vícekrát a je již téměř hotová. V příští lekci, Ošetření uživatelských vstupů, si ukážeme, jak zabezpečit všechny vstupy od uživatele.

Již toho umíme docela dost, začíná to být zábava, že? :)


 

Stáhnout

Staženo 950x (90.66 kB)
Aplikace je včetně zdrojových kódů v jazyce C#

 

 

Článek pro vás napsal David Čápka
Avatar
Jak se ti líbí článek?
63 hlasů
Autor pracuje jako softwarový architekt a pedagog na projektu ITnetwork.cz (a jeho zahraničních verzích). Velmi si váží svobody podnikání v naší zemi a věří, že když se člověk neštítí práce, tak dokáže úplně cokoli.
Unicorn College Autor sítě se informační technologie naučil na Unicorn College - prestižní soukromé vysoké škole IT a ekonomie.
Miniatura
Předchozí článek
Podmínky (větvení)
Miniatura
Všechny články v sekci
Základní konstrukce jazyka C#
Miniatura
Následující článek
Cvičení k 6. lekci C# .NET
Aktivity (11)

 

 

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

Avatar
Tereza Doležalová:4.2.2018 14:02

Malá nasobilka pomocí dvou cyklů: Kam mám prosím vložit metodu PadLeft(), aby se mi to zarovnalo? Děkuju

 
Odpovědět 4.2.2018 14:02
Avatar
HONZ4
Člen
Avatar
Odpovídá na Tereza Doležalová
HONZ4:4.2.2018 20:54

např.:

Console.Write( string.Format("{0}", i * j).PadLeft(4) );
Editováno 4.2.2018 20:55
 
Odpovědět 4.2.2018 20:54
Avatar
Petr Orság
Člen
Avatar
Petr Orság:15.2.2018 16:01

Super tutoriál, zkouším se naučit nějaké základy v C# a už mi z toho jde hlava kolem, ale snad to nějak půjde, díky moc za návod a rady!

 
Odpovědět  +1 15.2.2018 16:01
Avatar
Petr Zajac
Člen
Avatar
Petr Zajac:19.3.2018 17:44

V jedné učebnici C# jsem kromě cyklů "for" a "while" narazil ještě na cyklus
"do - while", který má vyhodnocování proměnné řídící cyklus na konci tj. provede se minimálně jednou i v případě, že není splněna podmínka.
Používá se tento cyklus ještě a pokud ANO uvedli byste někdo i příklad z praxe kdy?
Díky moc

 
Odpovědět 19.3.2018 17:44
Avatar
Filip Němeček
Redaktor
Avatar
Odpovídá na Petr Zajac
Filip Němeček:19.3.2018 21:05

V C# jsem několik let programoval (škola, práce, hobby) a pokud si dobře vzpomínám, tak jsem ho ani jednou nepoužil. Když ho budeš chtít za každou cenu využít, tak to asi půjde, ale přijde mi zbytečné ho držet v hlavě..

 
Odpovědět  +1 19.3.2018 21:05
Avatar
Pjanus
Člen
Avatar
Odpovídá na Petr Zajac
Pjanus:19.3.2018 21:36

Jak už bylo zmíněno používá se opravdu velmi vzácně. Jedná se o situace, ve kterých chceš nejprve něco vyhodnotit a až potom zkontrolovat jestli dál loopovat. Ale ano použil jsem ho asi jednou a i když je na místě tak se dá obejít klasickým while takže není špatné vědět, že něco takového existuje ale rozhodně to není zrovna podstatná znalost.

 
Odpovědět 19.3.2018 21:36
Avatar
Niko09185
Člen
Avatar
Niko09185:28.11.2018 23:38

Tvoj chybný kod = Console.Write­Line("Výsledek", vysledek);
Spravny kod = Console.Write­Line("Výsledek " + vysledek);

Operatorom + sa pridava premenna "vysledek" za text a nie čiarkou

 
Odpovědět 28.11.2018 23:38
Avatar
Tomáš Endlicher:1.12.2018 14:51

Mocninátor s while cyklem :-)

Console.WriteLine("Zadejte číslo k umocnění:");
            int a = int.Parse(Console.ReadLine());
            Console.WriteLine("Zadejte mocnitele:");
            int n = int.Parse(Console.ReadLine());

            int vysledek = a;
            int promenna = 1;
            while (promenna <= (n - 1))
            {
                promenna++;
                vysledek = a * vysledek;

            }
            Console.WriteLine("Výsledek: {0}", vysledek);
            Console.ReadKey();
 
Odpovědět 1.12.2018 14:51
Avatar
Senpai
Člen
Avatar
Senpai:20. ledna 17:25

Tohle jsem zvládl já, je to trošku lepší :) Tohle jsem dokázal za těch 6 lekcí :D. Snad ze mě bude jednou taky dobrý prográmator (mám tam i mocninu i odmocninu, musel jsem pozměnit postup zadávání, je to i tak lepší :D) Doufám že to někdo ocení :D

Console.Write­Line("Kalkulač­ka od Senpaie");
Console.Write­Line("Vyber jednu z 5 možností: ");

string pokracovat = "ano"; // Opakovaní
while (pokracovat == "ano") // Pokud dojde k odpovědí Ano bude se opakovat

{
Console.Write­Line("1 - Sčítání");
Console.Write­Line("2 - Odčítání");
Console.Write­Line("3 - Násobení");
Console.Write­Line("4 - Dělení");
Console.Write­Line("5 - Mocnina");
Console.Write­Line("6 - Odmocnina");
float volba2 = float.Parse(Con­sole.ReadLine());
if ((volba2 > 0) && (volba2 < 5)) //Sčitání, odčitání, násobení, dělení 2!! čísel
{
Console.Write­Line("Zadej prosím první číslo: ");
float a = float.Parse(Con­sole.ReadLine()); // První číslo (float.Parse kvůli změně na string)
Console.Write­Line("Zadej Druhé číslo: ");
float b = float.Parse(Con­sole.ReadLine()); // Druhé číslo (float.Parse kvůli změně na string)
float vysledek = 0; //musíme definovat prvně

switch (volba2) //Switch při zjednodušení,, Case znamená při dané hodnotě co má udělat
{
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 ((volba2 > 0) && (volba2 < 5))
{

Console.Write­Line("Výsledek příkladu je " + vysledek); // Vypíše výsledek
Console.Write­Line("Chcete pokračovat [ano/ne] ? ");

pokracovat = Console.ReadLine();
if (pokracovat == "ne")
{
Console.Write­Line("Pro ukončení zmáčkni libovolnou klávesu");
}

}
} //Sčitaní, Odčitaní...

else if (volba2 == 5) //Mocnina
{
Console.Write­Line("Napiš číslo které chceš umocnit");
float umoc = float.Parse(Con­sole.ReadLine());

if (umoc > 0)
{

float vysledek2 = umoc * umoc;
Console.Write­Line("Vysledek Mocniny " + umoc + " je " + vysledek2);
Console.Write­Line("Chcete pokračovat [ano/ne] ? ");
pokracovat = Console.ReadLine();
if (pokracovat == "ne")
{
Console.Write­Line("Pro ukončení zmáčkni libovolnou klávesu");
}

}

}//Mocnina

else if (volba2 == 6) //Odmocnina
{
Console.Write­Line("Napiš číslo které chceš odmocnit");
float odmoc = float.Parse(Con­sole.ReadLine());
if (odmoc > 0) //Pokud je číslo platné vypočítá
{

double vysledek3 = Math.Sqrt(odmoc); //Math.Sqrt = odmocnina
Console.Write­Line("Vysledek Odmocniny " + odmoc + " je " + vysledek3);
Console.Write­Line("Chcete pokračovat [ano/ne] ? ");
pokracovat = Console.ReadLine();
if (pokracovat == "ne")
{
Console.Write­Line("Pro ukončení zmáčkni libovolnou klávesu");
}
}

if (odmoc < 0) //Kdyby číslo bylo záporné
{
Console.Write­Line("Tohle číslo nejde odmocnit.");
Console.Write­Line("Chcete pokračovat [ano/ne] ? ");

pokracovat = Console.ReadLine();
if (pokracovat == "ne")
{
Console.Write­Line("Pro ukončení zmáčkni libovolnou klávesu");
}
}

}//Odmocnina

} //Celý program
Console.ReadKey();

}

}

 
Odpovědět 20. ledna 17:25
Avatar
Karel Rezek
Člen
Avatar
Karel Rezek:21. ledna 21:44

Kurz, který musí bavit každého, kdo se chce něco naučit. Velice dobře vše vysvětlováno. Mám za sebou 5 lekcí, uvidíme dál. Zatím jen plusy.

 
Odpovědět 21. ledna 21:44
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 159. Zobrazit vše