C # a hurok számára (példákkal)

Ebben a cikkben megismerjük a C # ciklusra vonatkozó tudnivalókat, valamint a programban történő felhasználásuk különböző módjait.

A programozás során gyakran kívánatos végrehajtani bizonyos utasításblokkot meghatározott számú alkalommal. Lehetséges megoldás az, hogy ezeket az utasításokat a szükséges számú alkalommal beírja. Előfordulhat azonban, hogy az ismétlések száma nem ismert előre (a fordítási idő alatt), vagy esetleg elég nagy (mondjuk 10000).

A legjobb megoldás erre a problémára a hurok. A programozási ciklusokat arra használják, hogy egy bizonyos utasításblokkot ismételten végrehajtsanak, amíg valamely feltétel nem teljesül.

Ebben a cikkben megnézzük a C # ciklusát.

C # a hurokhoz

A for kulcsszót a ciklus létrehozására használják a C # -ben. A ciklus szintaxisa :

 for (inicializálás; feltétel; iterátor) (// a hurok törzse)

Hogyan működik a hurok?

  1. C # hurok három nyilatkozatai: initialization, conditionés iterator.
  2. A initializationnyilatkozatot először és csak egyszer hajtják végre. Itt a változót általában deklarálják és inicializálják.
  3. Ezután conditionkiértékeli. Az conditionegy logikai kifejezés, vagyis vagy a, truevagy false.
  4. Ha a conditionkövetkezőt értékelik true:
    1. A for cikluson belüli utasítások végrehajtásra kerülnek.
    2. Ezután iteratorvégrehajtásra kerül az utasítás, amely általában megváltoztatja az inicializált változó értékét.
    3. Ismét az conditionértékelik.
    4. A folyamat addig folytatódik, amíg a conditionértékeljük, hogy false.
  5. Ha az conditionértéket kiértékeli false, a for ciklus véget ér.

a Loop folyamatábra számára

1. példa: C # a hurokhoz

 using System; namespace Loop ( class ForLoop ( public static void Main(string() args) ( for (int i=1; i<=5; i++) ( Console.WriteLine("C# For Loop: Iteration (0)", i); ) ) ) )

A program futtatásakor a kimenet a következő lesz:

 C # Hurok esetén: Iteráció 1 C # Hurok esetén: Iteráció 2 C # Hurok esetén: Iteráció 3 C # Hurok esetén: Iteráció 4 C # Hurok esetén: Iteráció 5

Ebben a programban

  • initialization állítás az int i=1
  • condition állítás az i<=5
  • iterator állítás az i++

Amikor a program fut,

  • Először az i változót deklaráljuk és inicializáljuk 1-re.
  • Ezután a feltétel ( i<=5) kiértékelésre kerül.
  • Mivel a feltétel visszatér true, a program végrehajtja a for ciklus törzsét. Az adott sort az Iteration 1-vel nyomtatja ki (az Iteration egyszerűen megismétlést jelent).
  • Most az iterátort ( i++) értékelik. Ez növeli az i értékét 2-re.
  • A ( i<=5) feltételt újra kiértékeljük, és a végén az i értékét 1-gyel növeljük. A feltétel trueaz első 5 alkalommal értékelődik .
  • Amikor az i értéke 6 lesz false, a feltétel pedig, akkor a hurok véget ér.

2. példa: a ciklushoz az első n természetes szám összegének kiszámításához

 using System; namespace Loop ( class ForLoop ( public static void Main(string() args) ( int n = 5,sum = 0; for (int i=1; i<=n; i++) ( // sum = sum + i; sum += i; ) Console.WriteLine("Sum of first (0) natural numbers = (1)", n, sum); ) ) )

A program futtatásakor a kimenet a következő lesz:

 Az első 5 természetes szám összege = 15

Itt az összeg és n értékét inicializáljuk 0-ra, illetve 5-re. Az i iterációs változót 1-re inicializáljuk, és minden egyes iterációnál növekszünk.

A for cikluson belül az összeg értékét növekszik i azaz sum = sum + i. A for ciklus addig folytatódik, amíg i értéke kisebb vagy egyenlő, mint n (felhasználói bemenet).

Lássuk, mi történik az adott programban az egyes iterációkon.

Kezdetben i = 1, összeg = 0 és n = 3

A hurok végrehajtási lépéseihez
Ismétlés I értéke i <= 5 Az összeg értéke
1 1 igaz 0 + 1 = 1
2 2 igaz 1 + 2 = 3
3 3 igaz 3 + 3 = 6
4 4 igaz 6 + 4 = 10
5. 5. igaz 10 + 5 = 15
6. 6. hamis A hurok véget ér

Tehát az összeg végső értéke 15 lesz, ha n = 5.

Több kifejezés egy for cikluson belül

Több kifejezést is használhatunk egy for for cikluson belül. Ez azt jelenti, hogy egy for cikluson belül több inicializálási és / vagy iterációs utasítással rendelkezhetünk. Lássuk az alábbi példát.

3. példa: többszörös inicializálási ciklushoz és iterátor kifejezésekkel

 using System; namespace Loop ( class ForLoop ( public static void Main(string() args) ( for (int i=0, j=0; i+j<=5; i++, j++) ( Console.WriteLine("i = (0) and j = (1)", i,j); ) ) ) )

A program futtatásakor a kimenet a következő lesz:

 i = 0 és j = 0 i = 1 és j = 1 i = 2 és j = 2

Ebben a programban két változót deklaráltunk és inicializáltunk: i és j az inicializációs utasításban.

Az iterátor részben két kifejezésünk is van. Ez azt jelenti, hogy mind az i, mind a j minden egyes iterációban 1-gyel növekszik.

Inicializálás nélküli ciklus és iterátor utasítások nélkül

The initialization, condition and the iterator statement are optional in a for loop. It means we can run a for loop without these statements as well.

In such cases, for loop acts as a while loop. Let's see the example below.

Example 4: for loop without initialization and iterator statement

 using System; namespace Loop ( class ForLoop ( public static void Main(string() args) ( int i = 1; for ( ; i<=5; ) ( Console.WriteLine("C# For Loop: Iteration (0)", i); i++; ) ) ) )

When we run the program, the output will be:

 C# For Loop: Iteration 1 C# For Loop: Iteration 2 C# For Loop: Iteration 3 C# For Loop: Iteration 4 C# For Loop: Iteration 5

In this example, we haven't used the initialization and iterator statement.

The variable i is initialized above the for loop and its value is incremented inside the body of loop. This program is same as the one in Example 1.

Hasonlóképpen, a feltétel szintén választható utasítás. Ha azonban nem használunk teszt kifejezést, akkor a for ciklus nem tesztel semmilyen feltételt, és örökké fog futni (végtelen ciklus).

Végtelen a hurokért

Ha a for ciklusban szereplő feltétel mindig igaz, akkor a ciklus örökké fog futni. Ezt végtelen ciklusnak nevezzük.

5. példa: Végtelen a hurokhoz

 using System; namespace Loop ( class ForLoop ( public static void Main(string() args) ( for (int i=1 ; i>0; i++) ( Console.WriteLine("C# For Loop: Iteration (0)", i); ) ) ) )

Itt i-t inicializáljuk 1-re, és a feltétel az i>0. Minden iteráción növeljük az i értékét 1-gyel, így a feltétel soha nem lesz false. Ez a hurok végtelen végrehajtását fogja eredményezni.

Végtelen ciklust is létrehozhatunk, ha a feltételt üresre cseréljük. Például,

 for (;;) (// hurok törzse)

vagy

 for (inicializálás;; iterátor) (// a hurok törzse)

érdekes cikkek...