Vezérlési szerkezetek, stringek

Itt meg kell ismerkednünk a Szekvencia - szabályal, amely a következőt jelenti:
a programok végrehajtása utasításról utasításra!

A szekvenciától, a vezérlési szerkezetekkel tudunk eltérni:

• elágazások
• ciklusok

Elágazások

E vezérlési szerkezetnek C#-ban 3 formája van:

1. egyszerű feltételes elágazás
2. öszetett feltételes elágazás
3. összetett feltételes elágazás

Egyirányú elágazás

Elágazásokat az if kulcsszóval tudunk képezni. Egy ilyen szerkezet alakja a következő lehet:  

if (feltétel) utasítás;

int szam = int.Parse(Console.ReadLine()); if (szam == 2)        Console.WriteLine("A bekért szám kettő"); Console.WriteLine("Kész");

A programban bekérünk egy számot billentyűzetről(parszoljuk, értelemszerűen ha double-t akkor daouble.Parse(...), kivétel a stringek!), majd megvizsgáljuk, ha a bekért szám egyenlő 2-vel, akkor kiírunk valamit.

Kétirányú elágazás

Az egyirányútól annyiban tér el, hogy az if után írjuk az else kulcsszót.
Az alakja a következő:

if (feltétel) {utasítás(ok)} else {utasítás(ok)};

Kódban: A bekért számról eldöntjük, hogy páros-e.

int szam = int.Parse(Console.ReadLine()); if (szam % 2 == 0)           Console.WriteLine("Páros."); else           Console.WriteLine("Páratlan.");

Összetett elágazás:

Akkor beszélünk összetett elágazásról, ha egy problémának több esete is lehet.
Ezt else if -kel oldjuk meg, azaz else if-ek követik egymást.

A C#-ban létezik egy szerkezet, amit könnyen és egyszerűen lehet használni, elkerülve a sok else if-et. A kód egyszerűbb, átláthatóbb lesz.
E szerkezetet a switch kulcsszóval tudjuk megvalósítani.

Random rnd = new Random(); byte nap = rnd.Next(1, 8); switch(nap) {  case 1:         //itt még állhatnak utsítások         //egészen a break-ig         Console.WriteLine("Hétfő");  break;  case 2:         Console.WriteLine("Kedd");  break;  case 3:         Console.WriteLine("Szerda");  break;  case 4:         Console.WriteLine("Csütörtök");  break;  case 5:         Console.WriteLine("Péntek");  break;  case 6:         Console.WriteLine("Szombat");  break;  case 7:         Console.WriteLine("Vasárnap");  break; }

Generálunk egy véletlen-számot 1 - 8 között, ezt a Random osztály segítségével tehetjük meg(a rnd.Next(min_ertek,max_ertek + 1); ). A Random osztályról bővebben: itt. Az előállított számot fogjuk vizsgálni a switch-be.
Értelemszerűen mindig abba az esetbe (case ágba) lépünk, amennyi a nap változó értéke. Pl. nap = 2, akkor a case 2-be lépünk, végrehajtjuk az utasításokat, majd break és kilépünk. Minden case végén kötelezően lenni kell egy break utasításnak, amely kilép a vezérlőszerkezetből! (A cilusoknál bővebben szó lesz róla).

Adódhat olyan probléma is, amikor nem teljesül egyetlen case ág sem, ekkor használjuk a default ágat.

Console.WritLine("Kérek egy számot 1 - 7  között!"); int nap = int.Parse(Console.ReadLine()); switch(nap) { case 1:        .... break; //szépen sorba, mint az  előző case 7:        .... break; default:         Console.WriteLine("Ilyen nap nem létezik!"); break; }

A ciklusok

Mikor van szükségünk ciklusra(iterációra): ha egy utasítást vagy utasítások sorozatát nem csak egyszer, hanem többször is végre kell hajtanunk!

A ciklusok két részből állnak:

• ciklusmag: azaz utasítás blokk, amelyet ismételni szeretnénk
• ciklus vezérlő feltétel: ő befolyásolja az ismétlést. Egy logikai feltétel, mely kiértékelése IGAZ vagy HAMIS lehet

Előltesztelős ciklusok: amennyiben a ciklus rögtön a vezérlő feltétel kiértékelésével kezd, ekkor lehetséges hogy a ciklusmag egyetlen-egyszer sem fut le. Ellenkező esetben hátultesztelős ciklusról beszélünk, ekkor legalábbb egyszer le fut a ciklus!

while

Pozitív vezérlésű, előltesztelős ciklus. Az if-hez hasonlóan, itt is egy feltételt írunk a zárójelbe. Két féle while ciklust írhatunk:

1. amikor nem tudjuk hányszor kell lefutnia a ciklusnak
2. amikor tudjuk hogy hányszor fusson le

Megtörténhet az is, hogy a ciklusmag egyszer sem fut le, de az is hogy a kiértékelés mindig IGAZ lesz, így végtelen ciklust kapunk.

Szintaktikája:

while (feltétel) { ciklusmag } ;

Példák:

1. Kérjünk be bill.ről egy pozitív számot!

int szam = 0; while (szam <= 0)   {      Console.WriteLine("Kérek egy pozitív számot!");      szam = int.Parse(Console.ReadLine());   } Console.WriteLine("Perfect :) ");

Ügyelnünk kell minden váltózóra, hogy mit és hol deklaráltaunk ill. a kezdőértékükre! Pl. ha szam valtozómat a feltételen belül deklarálom, akkor hibát dob a fordító, mivel nincs kezdőrtékem (int szam <= 0), lényegében definiálatlan a változóm!

2. Irassuk ki 20-ig a számokat!

int i = 0; while (i < 20)   {      Console.WriteLine("{0} ", i + 1);      i = i + 1;   } Console.Write("\nNa, 20szor lefutott!");

Van egy ciklus változónk, az i amiben azt tároljuk hogy hányszor futott le a ciklus. A számlálást az i+1-vel, vagyis a ciklus változót növeljük. A feltétel is egyszerű, az i addig fut amíg el nem éri a 20-at. Jelen esetben 19-szer fut le, mivel a következő kiértékeléskor az i értéke 20 lesz ami ellent mond az általunk megfogalmazott feltételnek.

for

Speciális ciklus, amely a while léptetős ciklusból ered(2.példa), gyakori használata miatt hozták létre ezt a ciklus fajtát, amit vektorok és listák feltöltésére és azok bejárására használjuk.

( Emlékszem az egyik gyakorlati órámra, ahol az egyik srác while ciklussal töltötte fel a listát, ami persze jó volt, csak nem szokás. Ezt követően 5 percig ismételtük a gyerekkel együtt, hogy "Listát for ciklussal töltünk fel!"
Lehetőleg kerüljük az ilyen bakikak.)

Szintaxisa: for (ciklusváltozó kezdőérték beáll.;vezérlő feltétel;léptető u.){}

Példák:

1.  Számok 20-ig

for (int i = 0; i < 20; i++)   {     Console.WriteLine("{0} ",i + 1);   }

Láthatjuk, tényleg hasonlít a while-ra. A különbség: hogy minden a záró jelen belül  szerepel. (Áttekinthetőbb a ciklus vezérlése, a törzsben pedig csak utasítások állnak,)

Ez is helyes:

for (int i = 0; i < 20)   {     Console.WriteLine("{0} ",i + 1);     i++;    }

Listabejáró ciklus - foreach

Speciális ciklus, amit listák bejárására használunk. (Feltételezzük, hogy van egy lista nevű listánk)

int x = 0; foreach (x < lista.Count) { Console.WriteLine("{0} ",x); }

 Bővebben a listáknál lesz bemutatva.

Stringek

A stringek másik neve a karakterlánc, mivel karakterekből(char) épül  fel.
Így tehát a string, tekinhtető egy tömbnek is amiben karaktereket tárolunk.

string s = "szöveg"; Console.WriteLine(s);

A következő példában kivesszük a második karaktert, ezzel bizonyítva hogy a stringek referencia típusok, karakterek sorozatából áll.

string s = "karakterek"; Console.WriteLine("A második karakter: ",s[1]) //a

A C# sok hasznos metódust biztosít a stringek kezelésére, és egy metódusnak számos változata lehet!

Oldal: Vezérlési szerkezetek, stringek
Information Technology - Információ Technológia - © 2008 - 2024 - prog-tech.hupont.hu

A HuPont.hu segítségével egyszerű a honlap készítés! Programozói tudás nélkül is: Honlap készítés

ÁSZF | Adatvédelmi Nyilatkozat