Ciklusok si-sharpe-ban
A ciklusokat egy kód ismételt megismétlésére használják.
Négy hurok operátor van a C-Sharp-ban: a, míg a do-while, foreach.
Ezt a ciklust akkor használjuk, ha előre ismert, hogy hány ismétlést kell végrehajtani. Ennek szerkezete a következő:
for (számláló inicializálás, folytatás feltétel, iteráció)
// ismételt kódblokk
>
Példa egy olyan programra, amely megjeleníti a 0, 1, 2, 3, 4 számokat:
statikus érvénytelen Main (string [] args)
az (int i = 0; i <5; i++) // цикл выполнится 5 раз
Console.WriteLine (i);
>
>
Először a számláló létrejön és inicializálódik, i = 0. Ezután a feltétel (i <5), если результат будет «истина», то дальше выполняется блок кода в теле цикла. В конце итерации происходит изменение значения счетчика (в данном примере увеличение на единицу). После этого вновь происходит проверка условия и так далее. Когда условие будет «ложь», цикл работу завершит.
Példa egy olyan programra, amely megtalálja és megjeleníti a tömbelemek összegét:
statikus érvénytelen Main (string [] args)
int [] számok = <4, 7, 1, 23, 43>;
int s = 0;
az (int i = 0; i
>
Console.WriteLine (s);
Console.ReadKey ();
>
Példa a for loopra, amikor a számláló minden iteráció után csökken:
mert (int i = 5; i> 0; i--) // futni ötször
Console.WriteLine (i);
>
A számláló nemcsak egyével módosítható. Példa egy olyan programra, amely páros számokat nyomtat (az 50-es számmal):
az (int i = 0; i <= 50; i+=2) //выполнится 26 раз
Console.WriteLine (i);
>
A szó miközben "mostanra" fordítja, ami jól jellemzi. Folytatódik, amíg egy bizonyos feltétel igaz. Ez a szerkezet:
míg (folytatás)
// ismételt kódblokk
>
Először ellenőrizzük a feltételt, majd végrehajtjuk a kódblokkot.
Példa egy programra, amely 0, 1, 2, 3, 4 számot jelenít meg:
A hurok végrehajtható "örökre", ha mindig az igazi állapotot állítja be:
míg (igaz)
Console.WriteLine ("Perpetual Cycle");
>
Ez ugyanaz a ciklus alatt, csak itt van egy kódblokk végrehajtása először, majd az állapot be van jelölve. Ez garantálja legalább egy ciklusát.
csinál
// ismételt kódblokk
>
míg (folytatás);
Példa egy olyan programra, amely nem hagyja abba az 5-ös szám beírását a billentyűzetből:
statikus érvénytelen Main (string [] args)
int szám;
csinál
Console.WriteLine ("Enter number 5");
number = KonvertálásToInt32 (Console.ReadLine ());
>
míg (szám = 5);
>
A foreach-hurkot külön leckében fogjuk beszélni.
Bármelyik ciklusból az idő előtt kiléphet a szüneteltetési utasítással. Használja ezt az operátort, ha bizonyos feltételek teljesülése után értelme van, ellenkező esetben a hurok az első iteráció befejeződik.
Példa egy olyan programra, amely ellenőrzi, hogy a tömbben többszörös-e 13. Miután ilyen számot találtunk meg, nincs értelme a tömb többi elemének további ellenőrzését, és itt használjuk a törésmutatót:
statikus érvénytelen Main (string [] args)
int [] számok = <4, 7, 13, 20, 33, 23, 54>;
bool b = hamis;
az (int i = 0; i
b = igaz;
break;
>
>
Console.WriteLine (b. "A tömbben 13-nak többszöröse van." "A tömbben nincs többszörös 13");
Console.ReadKey ();
>
Ez az operátor lehetővé teszi, hogy a következő iterációhoz menjen, anélkül, hogy befejezte az aktuálisat.
Példa egy olyan programra, amely egy tömb páratlan elemeit összegzi:
statikus érvénytelen Main (string [] args)
int [] számok = <4, 7, 13, 20, 33, 23, 54>;
int s = 0;
az (int i = 0; i
tovább; // menj a következő iterációhoz
s + = számok [i];
>
Console.WriteLine (s);
Console.ReadKey ();
>
1. feladat: Az 1., 4., 7., 10., 13. sorrend 20 elemének megjelenítése
Feladat 2. Írjon be egy programot, amely "megköveteli" a helyes jelszót, amíg be nem írja. A helyes jelszónak "root" -nak kell lennie.
3. probléma. Két azonos hosszúságú tömböt kapunk (10 elem mindegyik). Hozzon létre egy harmadik tömböt, amely megjeleníti az első két tömb összegét. A harmadik tömb első eleme megegyezik az első két tömb első elemeinek összegével és így tovább.
Cycle operator foreach a C-Sharp-ban
A C-Sharp foreach loop operátorának feladata a gyűjtemény elemeinek felsorolása. A gyűjtemények közé tartozik a tömbök, a listalista és az egyéni gyűjtőosztályok. Ebben a megállapításban nem kell létrehoznia egy változószámlálót a gyűjtemény elemeinek eléréséhez, ellentétben más ciklusokkal. A foreach nyilatkozat szerkezete a következő:
foreach ([típus] [változó] a [gyűjteményben])
// a hurok teste
>
Példa egy olyan programra, amely a foreach hurok használatával tartalmazza a tömbelemek összegét:
foreach (int számok)
s + = el;
>
Console.WriteLine (s);
Console.ReadKey ();
>
Minden egyes iterációnál a gyűjtemény elemét egymás után írjuk az el változóra. Az első iterációnál az el értéke "4". a második iteráció - "7" stb.
Mint más hurok esetében, használhatsz szünetet és folytathatod a nyilatkozatokat a foreachban.
A foreach-hurok használatával megjelenítheti a 20-nál nagyobb és 50-nél kisebb egész számok összes elemét.
Funkciók a C-Sharp-ban. Visszatérési nyilatkozat
A függvény egy kis szubrutin. Ha egy program egyszerűen megoldás néhány alkalmazott probléma, akkor ez a funkció is megoldás, csak a programon belül, és ennek megfelelően elvégzi a feladatot "egyszerűbb". A funkciók lehetővé teszik a program méretének csökkentését, mivel nem kell újraírnia a kódfájlokat - csak annyit hívunk, amennyit csak akarunk, és ahol a deklarált függvény szükséges.
A C-Sharp funkcióit más módszereknek is nevezik. E két fogalom között a különbség kicsi, és itt fogjuk használni a kifejezés funkciót.
[hozzáférési módosító] [visszatérési típus] [függvény neve] ([argumentumok])
// a funkció teste
>
A hozzáférési módosító (hatókörök) lehet nyilvános, privát, védett, belső. Mire lesz szükség külön leckében beszélni, de mostanra mindenhol nyilvánosan használjuk.
A módosító és a típus között a statikus kulcs állhat, ami azt jelenti, hogy a függvény statikus lesz. Részletesen beszélünk a statikus függvényekről és változókról külön leckében. Csak azt mondom, hogy más funkciók hívhatók statikus függvényből, ha azok szintén statikusak. A főfunkció mindig statikus, ezért a lecke statikus összes funkcióját is kijelentjük.
A függvény visszatérhet egy értékhez, vagy nem tér vissza. Ha például a függvény egy egész számot ad ki, meg kell adnia a type int értéket. Ha a függvény nem ad vissza semmilyen értéket, akkor ehhez a kulcsszavakat használják. Az olyan funkciókat, amelyek nem adnak vissza értéket, szintén az eljárásoknak nevezik.
A hívó funkciók olyanok, hogy a név tükrözi a funkció lényegét. Használjon verbokat vagy szóösszetételeket igékkel. Példák: GetAge (), Sort (), SetVisibility ().
Az argumentumok azok a adatok, amelyek egy függvény végrehajtásához szükségesek. Az érvek a [típus] [azonosító] formátumban vannak írva. Ha több érv van, elválaszthatók vesszővel. Az érvek hiányozhatnak.
A függvény első sorában, amely meghatározza a típust, a nevet, az érveléseket stb. a funkció fejlécének nevezik.
Tehát van elég elmélet, viszont a gyakorlathoz fordulunk.
Példa egy olyan funkcióra, amely nem ad vissza értéket
Írjunk egy egyszerű függvényt, amely a megadott név helyett egy másikat a string tömbben cserél. Ez a függvény három argumentumot tartalmaz: egy sor tömb, a helyettesítendő név és egy új név. Mivel a függvény nem ad vissza értéket, adja meg az üres típust a függvény neve előtt.
public static void ReplaceName (string [] nevek, karakterláncnév, string newName)
az (int i = 0; i
nevek [i] = newName;
>
>
Maga a funkció nagyon egyszerű. Megkeressük az elemek hurokját, és látjuk, hogy az elem megegyezik-e a megadott névvel. Ha igen, új névvel helyettesítjük.
A funkció meg van írva, és most használjuk:
osztályú programot
public static void ReplaceName (string [] nevek, karakterláncnév, string newName)
az (int i = 0; i
nevek [i] = newName;
>
>
statikus érvénytelen Main (string [] args)
karakterlánc [] names = <"Sergey", "Maxim", "Andrey", "Oleg", "Andrey", "Ivan", "Sergey">;
ReplaceName (nevek, "Andrey", "Nikolay"); // hívja a funkciót. A sorban szereplő "Andrey" sorokat a "Nikolay"
ReplaceName (nevek, "Ivan", "Vladimir");
>
>
Miután kétszer meghívta a függvényt ebben a programban, a tömb úgy fog kinézni, mint: "Sergey", "Maxim", "Nikolay", "Oleg", "Nikolay", "Vladimir", "Sergey".
Példa egy olyan függvényre, amely visszaadja az értékeket
Írjunk egy olyan függvényt, amely megtalálja a maximális számot a tömbben. Ennek a függvénynek az argumentuma egy egész szám lesz. A visszatérési típus egy egész szám.
nyilvános statikus int GetMax (int [] tömb)
int max = tömb [0];
az (int i = 1; i
max = tömb [i];
>
return max;
>
A funkció logikája egyszerű. Hozzon létre egy változót max, amelyben a tömb első elemét írjuk. A ciklusban minden egyes elemet max értékkel hasonlítjuk össze, ha az elem nagyobb, mint max, akkor ezt az elemet max. A funkció végén a visszaváltó feladata az eredmény visszaadása.
A visszatérési nyilatkozatnak mindig olyan függvénynek kell lennie, amely visszaad egy értéket.
Használjuk funkciónkat:
osztályú programot
nyilvános statikus int GetMax (int [] tömb)
int max = tömb [0];
az (int i = 1; i
max = tömb [i];
>
return max;
>
statikus érvénytelen Main (string [] args)
int [] számok = <3, 32, 16, 27, 55, 43, 2, 34>;
int max;
max = GetMax (számok); // hívja ezt a funkciót akkor, ha hozzárendel egy értéket
Console.WriteLine (GetMax (számok)); // a függvényhívás argumentumként is használható, amikor egy másik funkciót hív meg. A WriteLine () szintén függvény.
Console.ReadKey ();
>
>
Amikor ez az operátor találkozik, a funkció kilép a funkcióból, és az alábbi kód (ha van ilyen) nem kerül végrehajtásra (például egy argumentum átadódik a függvénynek, amelyben nincs értelme végrehajtani a függvényt). Ez hasonló a töréskifejezéshez, amelyet a hurkok kilépésére használnak. Ez az operátor olyan függvényekben is használható, amelyek nem adnak vissza értéket. A visszatérési nyilatkozat többször használható egy függvényben, de ez nem ajánlott.
Feladat 1. Írjon egy olyan függvényt, amely az egész értéktartományba tartozó összes olyan elemet megváltoztatja, amelyek megjelennek a megadott értéknek (argumentumnak) az ellenkező értékig. Például a tömb összes eleme, amely egyenlő 5-el, -5-re változik.
Feladat 2. Írj egy olyan funkciót, amely megtalálja a legkevesebb három számot.
3. feladat: Írj egy olyan függvényt, amely visszaadja a Fibonacci-sorozat meghatározott elemét. A Fibonacci-sorozat olyan sorozat, amelyben minden egyes következő elem egyenlő a két előző összegével. 1 1 2 3 5 8 13 21 ... A függvény az elem sorozatszámát veszi fel, és visszaküldi a megfelelő elemet.