C # while en do ... while loop (met voorbeelden)

In dit artikel zullen we leren over while en do … while-lus in C #, hoe je ze kunt gebruiken en hoe je ze kunt onderscheiden.

Bij het programmeren is het vaak gewenst om een ​​bepaald blok instructies een gespecificeerd aantal keren uit te voeren. Een mogelijke oplossing is om die instructies het vereiste aantal keren in te typen. Het is echter mogelijk dat het aantal herhalingen niet van tevoren bekend is (tijdens het compileren) of misschien groot genoeg is (bijvoorbeeld 10.000).

De beste oplossing voor een dergelijk probleem is lus. Lussen worden gebruikt bij het programmeren om herhaaldelijk een bepaald blok met instructies uit te voeren totdat aan een bepaalde voorwaarde is voldaan.

In dit artikel zullen we leren while-loops in C # te gebruiken.

C # while-lus

Het while- trefwoord wordt gebruikt om een ​​while-lus in C # te maken. De syntaxis voor while-lus is:

 while (test-expression) (// body of while)

Hoe werkt while-lus?

  1. C # while-lus bestaat uit een test-expression.
  2. Als het test-expressionwordt geëvalueerd naar true,
    1. instructies binnen de while-lus worden uitgevoerd.
    2. na uitvoering wordt de test-expressionopnieuw geëvalueerd.
  3. Als de test-expressionwordt geëvalueerd naar false, wordt de while-lus beëindigd.

while-lus Stroomdiagram

Voorbeeld 1: while Loop

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

Wanneer we het programma uitvoeren, is de uitvoer:

 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

Aanvankelijk is de waarde van i 1.

Wanneer het programma de instructie while-lus bereikt,

  • de testuitdrukking i <=5wordt geëvalueerd. Omdat i 1 is en 1 <= 5is true, voert het de body van de while-lus uit. Hier wordt de regel op het scherm afgedrukt met herhaling 1, en de waarde van i wordt verhoogd met 1 om 2 te worden.
  • Nu wordt de testuitdrukking ( i <=5) opnieuw geëvalueerd. Ook deze keer retourneert de uitdrukking true(2 <= 5), dus de regel wordt op het scherm afgedrukt en de waarde van i wordt nu opgehoogd tot 3 …
  • Dit gaat en de while-lus wordt uitgevoerd totdat i 6 wordt. Op dit punt zal de testuitdrukking evalueren tot falseen daarmee wordt de lus beëindigd.

Voorbeeld 2: while-lus om de som van de eerste 5 natuurlijke getallen te berekenen

 using System; namespace Loop ( class WhileLoop ( public static void Main(string() args) ( int i=1, sum=0; while (i<=5) ( sum += i; i++; ) Console.WriteLine("Sum = (0)", sum); ) ) )

Wanneer we het programma uitvoeren, is de uitvoer:

 Som = 15

Dit programma berekent de som van de eerste 5 natuurlijke getallen.

  • Aanvankelijk wordt de waarde van som geïnitialiseerd op 0.
  • Bij elke iteratie wordt de waarde van som bijgewerkt naar sum+ien wordt de waarde van i verhoogd met 1.
  • Wanneer de waarde van i 6 bereikt, i<=5retourneert de testuitdrukking false en wordt de lus beëindigd.

Laten we eens kijken wat er bij elke iteratie in het gegeven programma gebeurt.

Aanvankelijk i = 1, som = 0

While loop uitvoeringsstappen
Iteratie Waarde van i ik <= 5 Waarde van de som
1 1 waar 0 + 1 = 1
2 2 waar 1 + 2 = 3
3 3 waar 3 + 3 = 6
4 4 waar 6 + 4 = 10
5 5 waar 10 + 5 = 15
6 6 false Loop eindigt

De uiteindelijke waarde van de som is dus 15.

C # do… while loop

Het do en while- trefwoord wordt gebruikt om een ​​do… while-lus te maken. Het is vergelijkbaar met een while-lus, maar er is een groot verschil tussen beide.

In de while-lus wordt de conditie gecontroleerd voordat de body wordt uitgevoerd. Het is precies het tegenovergestelde in do… while-lus, dwz de conditie wordt gecontroleerd nadat de body is uitgevoerd.

Dit is de reden waarom de body van do… while-lus minstens één keer zal worden uitgevoerd, ongeacht de test-uitdrukking.

De syntaxis voor do … while loop is:

 do (// body of do while loop) while (test-uitdrukking);

Hoe werkt de while-lus?

  1. De body van do… while-lus wordt eerst uitgevoerd.
  2. Vervolgens test-expressionwordt het geëvalueerd.
  3. Als dat het geval test-expressionis true, wordt de body of loop uitgevoerd.
  4. Als dat zo test-expressionis false, doe dan… while-lus eindigt.

do… while loop Stroomdiagram

Voorbeeld 3: do… while-lus

 using System; namespace Loop ( class DoWhileLoop ( public static void Main(string() args) ( int i = 1, n = 5, product; do ( product = n * i; Console.WriteLine("(0) * (1) = (2)", n, i, product); i++; ) while (i <= 10); ) ) )

Wanneer we het programma uitvoeren, is de uitvoer:

 5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25 5 * 6 = 30 5 * 7 = 35 5 * 8 = 40 5 * 9 = 45 5 * 10 = 50

As we can see, the above program prints the multiplication table of a number (5).

  • Initially, the value of i is 1. The program, then enters the body of do… while loop without checking any condition (as opposed to while loop).
  • Inside the body, product is calculated and printed on the screen. The value of i is then incremented to 2.
  • After the execution of the loop’s body, the test expression i <= 10 is evaluated. In total, the do… while loop will run for 10 times.
  • Finally, when the value of i is 11, the test-expression evaluates to false and hence terminates the loop.

Infinite while and do… while loop

If the test expression in the while and do… while loop never evaluates to false, the body of loop will run forever. Such loops are called infinite loop.

For example:

Infinite while loop

 while (true) (// body van while-lus)

Oneindige do… while-lus

 do (// body van while-lus) while (true);

De oneindige lus is handig als we een lus nodig hebben om te draaien zolang ons programma draait.

Als uw programma bijvoorbeeld een animatie is, moet u het constant uitvoeren totdat het wordt gestopt. In dergelijke gevallen is een oneindige lus nodig om de animatie herhaaldelijk te laten draaien.

Interessante artikelen...