Menü

Schleifen in C #: Steueranweisungen und verschiedene Schleifen mit Beispielen

  • Haupt
  • Andere
  • Schleifen in C #: Steueranweisungen und verschiedene Schleifen mit Beispielen

loops c control statements

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Schleifen in C # Ermöglichen Sie dem Programm, einen Codeblock mehrmals auszuführen. In diesem Lernprogramm werden verschiedene Schleifen wie While-Schleifen, For-Schleifen usw. anhand von Beispielen erläutert:

In unserem vorherigen Tutorial haben wir etwas anderes gelernt C # -Operatoren als kann in Verbindung mit den Entscheidungserklärungen verwendet werden, um einem erforderlichen Ausführungsablauf zu folgen.

In diesem Tutorial werden die C # -Schleifenanweisungen erläutert, mit denen das Programm iterative Logik ausführen kann.

=> Hier finden Sie unseren ultimativen C # -Trainingsleitfaden

Schleifen in C #

Was du lernen wirst:

Schleifen in C #: Eine vollständige Übersicht

Alle in C # geschriebenen Anweisungen werden nacheinander ausgeführt. Es kann jedoch vorkommen, dass das Programm ein bestimmtes Codefragment mehrmals ausführen muss. Um diese Situation zu bewältigen, bietet C # Steueranweisungen an, mit denen komplizierte Ausführungsabläufe verarbeitet werden können .

Eine Schleife ermöglicht es dem Programm, einen Codeblock mehrmals auszuführen, indem eine allgemeine Anweisung in C # befolgt wird. C # bietet verschiedene Arten von Schleifen, um unterschiedliche Anforderungen an die Programmierausführung zu erfüllen.

Kontrollanweisung

Bevor wir mit der Arbeit an Schleifen beginnen, müssen wir wissen, was eine Steueranweisung ist. Eine Steueranweisung ermöglicht es der Schleife, ihren Kurs von ihrer normalen Sequenz zu ändern. Die Programmiersprache C # bietet die folgenden grundlegenden Regelungsanweisungen.

Erklärung fortsetzen

Die Continue-Anweisung in C # wird aus folgenden Gründen verwendet:

  • So führen Sie die nächste Iteration der Schleife aus, während Sie den dazwischen liegenden Code überspringen.

Die Syntax der continue-Anweisung lautet „ fortsetzen;'

Break Statement

Die Break-Anweisung in C # wird aus folgenden Gründen verwendet:

Implementieren Sie einen binären Suchbaum in Java
  • Es wird verwendet, um eine Schleife zu beenden, damit das Programm mit der nächsten Schleifenanweisung fortfahren kann. In verschachtelten Schleifen kann damit die Ausführung der inneren Schleife gestoppt werden, wodurch die Programmsteuerung für die nächste Anweisung nach dem aktuellen Code bereitgestellt wird.
  • Es kann verwendet werden, um eine Anweisung in der zu beenden Schaltergehäuse.

Die Syntax der break-Anweisung lautet „ brechen;'

While-Schleife

Die while-Schleife validiert eine Bedingung und führt dann den Codeblock aus, solange die in while definierte Bedingung wahr ist.

Syntax

While(Boolean Condition) { //code block// }

Wichtige Hinweise:

  • Die boolesche Anweisung wird vor der Ausführung des Codes überprüft.
  • Wenn der boolesche Ausdruck als wahr bestätigt wird, wird nur der Code ausgeführt.
  • Sobald der Codeblock ausgeführt wurde, kehrt das Steuerelement zur Auswertung zu einer Booleschen Anweisung zurück.
  • Die Schleife wird so lange ausgeführt, wie der Boolesche Ausdruck true ergibt.
  • Wenn der Boolesche Ausdruck false ergibt, wird der Codeblock übersprungen und die nächste Zeile des Codes außerhalb der while-Schleife ausgeführt.
  • Stellen Sie immer sicher, dass die mit einem Booleschen Ausdruck verwendete Variable aktualisiert wird, damit das Ende der Schleife bei der erwarteten Iteration erkannt wird.
  • Wenn die der while-Schleife zugeordnete Variable nicht aktualisiert wird oder immer einen wahren Wert zurückgibt, wird sie zu einer Endlosschleife.

Beispiel einer einfachen While-Schleife:

int a = 0; while (a <5) { Console.WriteLine(“The value of a is :”+a); a++; } Console.WriteLine(“The while block has been executed”);

Code Erklärung

Im obigen Programm haben wir den Booleschen Ausdruck als (a<5) for “while”. It means that the loop will continue to execute the code snippet as long as the value of “a” is less than 5.

Im Codeblock drucken wir den Wert von 'a' und haben dann den Inkrementoperator hinzugefügt. Wie bereits in unserem vorherigen Tutorial erläutert, wird der Inkrementoperator verwendet, um den Wert der Ganzzahl um 1 zu erhöhen. Sobald der Wert von „a“ auf der Konsole gedruckt wurde, durchläuft das Steuerelement den Inkrementoperator, wodurch seine Größe erhöht wird um 1.

Jetzt bewegt sich das Steuerelement, um den Booleschen Ausdruck auszuwerten. Für das aktuelle Beispiel, da wir den Anfangswert von a bereits als '0' definiert haben, wird er um '1' erhöht. Der boolesche Ausdruck wird also zu (1<5) which will evaluate to “true” and the code block inside the loop will get executed.

Sobald der Wert von 'a' 5 erreicht, wird die Ausführung gestoppt, da der Boolesche Ausdruck nun als falsch gelesen wird. Sobald der Boolesche Ausdruck false zurückgibt, existiert die Steuerschleife und führt die nächste Codezeile außerhalb des while-Blocks aus.

Wenn das Programm ausgeführt wird, erfolgt die Ausgabe wie folgt:

Ausgabe

Der Wert von a ist: 0
Der Wert von a ist: 1
Der Wert von a ist: 2
Der Wert von a ist: 3
Der Wert von a ist: 4
Der while-Block wurde ausgeführt

Do While-Schleife

Do while-Schleife ähnelt der while-Schleife mit einem Unterschied. Die Bedingung wird am Ende der Schleife ausgewertet, anstatt wie im Fall einer while-Schleife beschrieben zu beginnen. Dies verleiht dieser Schleife ein einzigartiges Merkmal, d. H. Sie führt die Anweisung mindestens einmal innerhalb der Schleifengrenze aus.

Während andere Schleifen den Booleschen Ausdruck am Anfang auswerten, bedeutet dies, dass eine Schleife nicht ausgeführt wird, wenn der Ausdruck falsch ist.

Syntax

do { //code block for execution// } while( Boolean expression );

Wichtige Hinweise:

Load Balancing Router zwei Internetverbindungen
  • 'Do while' funktioniert ähnlich wie eine while-Schleife. Das Schlüsselwort Do wird am Anfang des Codeblocks und das while nach dem Codeblock platziert.
  • Der Boolesche Ausdruck wird am Ende der Schleife anstatt am Anfang ausgewertet. Wenn die Bedingung als wahr zurückgegeben wird, wird die Schleife fortgesetzt. Wenn der Ausdruck false zurückgibt, endet die Schleife dort selbst.
  • 'Do while' führt den Codeblock mindestens einmal innerhalb der Schleifengrenzen aus.

Beispiel einer einfachen Do-While-Schleife:

int nmbr = 5; /* do loop starts*/ do { Console.WriteLine('value of nmbr is '+ nmbr); nmbr++; } while (nmbr <10); Console.ReadLine();

Code Erklärung

Im obigen Code haben wir eine Ganzzahl 'nmbr' mit dem Wert 5 deklariert. Dann haben wir die Schleife durch Platzieren des Schlüsselworts 'Do' gestartet. Nach dem Do und innerhalb der geschweiften Klammern haben wir den Code definiert, den wir ausführen möchten. Hier drucken wir nur den Wert der nmbr-Ganzzahl in die Konsole. Sie können Ihren eigenen komplexen Code in die Klammern schreiben.

Wie wir sehen können, erhöhen wir den Wert von nmbr, nachdem wir ihn gedruckt haben. Sobald der Codeblock verarbeitet ist, wechselt das Steuerelement zu 'while', wo der Boolesche Ausdruck ausgewertet wird. Bis die nmbr einen Wert von weniger als 10 hat, wird die Schleife hier weiter iteriert.

Wenn wir also dieses Code-Snippet ausführen, kann die folgende Ausgabe beobachtet werden:

Ausgabe

Wert von nmbr ist 5
Wert von nmbr ist 6
Wert von nmbr ist 7
Wert von nmbr ist 8
Wert von nmbr ist 9

Einmal hat der Wert des nmbr 10 erreicht (durch Inkrementieren mit jeder Iteration). Dann gibt die while-Bedingung einen falschen Wert zurück, da er nicht länger als 10 ist. Dadurch verlässt die Steuerung die Schleife „Do while“ und die Steuerung geht zur nächsten Codezeile über.

Für Schleife

Die for-Schleife in C # folgt einer anderen Syntax als die while-Schleife. Die Bedingung der 'for' -Schleife enthält die Initialisierung und Änderung der Bedingung innerhalb der Syntax selbst. Die 'for' -Schleife ist sehr nützlich, wenn Sie die genaue Anzahl der Iterationen kennen, die Sie für die Schleife ausführen müssen.

Die Definition in der Klammer der Schleife enthält drei Teile, die durch Semikolons voneinander getrennt sind. Der erste Teil ist die Initialisierung, dann haben wir einen Booleschen Ausdruck, gefolgt von der Iterationsliste.

Syntax

for(initializer; boolean expression; iteration list) { //code block for execution// }

Der erste Teil des Ausdrucks ist der Initialisierungsblock. Dieser Ausdruck wird verwendet, um die Ganzzahlvariable zu initialisieren. Dies liefert den Wert am Anfang der Schleife.

Der zweite Teil ist der Boolesche Ausdruck, der verwendet wird, um die wahre oder falsche Bedingung für die Fortsetzung der Schleife genau wie die while-Schleife auszuwerten.

Der dritte Ausdruck ist der Iterationsteil. Hier können wir die Inkrementoperatoren oder Dekrementoperatoren verwenden, um den Wert der initialisierten Variablen gemäß den Ausführungsanforderungen zu erhöhen oder zu verringern.

Wichtige Hinweise:

  • Bei Schleifen in C # können die Programmierer die genaue Anzahl der auszuführenden Iterationen definieren.
  • Die for-Schleife enthält neben dem Booleschen Ausdruck auch Initialisierungs- und Iterationsausdrücke, um eine Bedingung für die Schleife bereitzustellen.
  • For-Schleife wird verwendet, wenn wir die Anzahl der für die Schleife erforderlichen Iterationen genau kennen.
  • Die Initialisierung der Variablen erfolgt zu Beginn der Schleife.
  • Nach der Initialisierung wird das Steuerelement zur Überprüfung des Booleschen Ausdrucks an den zweiten Abschnitt übergeben. Der Boolesche Ausdruck kann so komplex sein, wie Sie möchten, aber das Ergebnis sollte immer true oder false als Wert zurückgeben.
  • Nachdem der Boolesche Ausdruck als wahr ausgewertet wurde, wird der Codeblock in den geschweiften Klammern ausgeführt, und das Steuerelement bewegt sich erneut an den Anfang der Schleife, und der Inkrementierungs- oder Dekrementierungsoperator wird ausgeführt.
  • Nachdem die Iterationsliste ausgeführt wurde, wechselt das Steuerelement zur Auswertung erneut zum Booleschen Ausdruck, und die Schleife iteriert, wenn sie 'true' zurückgibt, oder die nächste Codezeile außerhalb der Schleife wird ausgeführt, wenn sie false zurückgibt.

Beispiel einer einfachen For-Schleife:

/* for loop starts*/ for(int i=0; i<5; i++) { Console.WriteLine('value of i is '+ i); }

Code Erklärung

Im obigen Code haben wir die Ganzzahl i als 0 initialisiert. Dann haben wir den Booleschen Ausdruck bereitgestellt, um zu bewerten, ob i kleiner als 0 ist, und einen Inkrementoperator.

Die Initialisierung erfolgt zu Beginn der Schleife, dann wird die Boolesche Bedingung ausgewertet, gefolgt von der Ausführung des Codeblocks in geschweiften Klammern. Die Steuerung wird dann wieder an den Inkrementoperator oben übergeben, der den Wert von i während jeder Iteration um 1 erhöht.

Schauen wir uns die Ausgabe genauer an.

Ausgabe

Wert von i ist 0
Wert von i ist 1
Wert von i ist 2
Wert von i ist 3
Wert von i ist 4

Für jede Schleife

Eine For Each-Schleife wird verwendet, wenn ein Programm den Inhalt einer Liste durchlaufen muss. Es kann für Sammlungen wie Array-Listen oder Arrays verwendet werden.

Syntax

foreach(item_type iterative_variable in list_type) { //code block for execution// }

Der 'item_type' in der Syntax ist der Typ des in der Liste enthaltenen Elements. Beispielsweise, Wenn wir ein Integer-Array verwenden, ist der Typ Integer oder Int.

Die 'iterative_variable' ist ein von Ihnen gewählter Variablenname und das 'in' ist ein Schlüsselwort, das verwendet wird.

Der 'list_type' ist der von Ihnen verwendete Listentyp. Zum Beispiel, Wenn wir ein Integer-Array verwenden, ist der Listentyp der Name des Int-Arrays.

Wichtige Hinweise:

  • Für jede Schleife wird der Codeblock für jedes in der angegebenen Sammlung vorhandene Element ausgeführt.
  • Jede Schleife ist schreibgeschützt, daher können Sie die Iterationsvariable während der Ausführung nicht ändern.
  • Für jede Iteration, die diese Schleife verwendet, wird ein neuer Wert aus der Liste abgerufen. Der Wert wird dann in die schreibgeschützte Variable eingefügt.
  • Sobald alle Elemente der Liste während der Iteration erschöpft sind, geht das Steuerelement zur nächsten Codezeile über.

Beispiel einer einfachen für jede Schleife:

/* specifies list*/ int() list = {1,2,3,4,5}; /* foreach loop starts*/ foreach (int nmbr in list) { Console.WriteLine('Numbers present in list are '+ nmbr); }

Code Erklärung

Zunächst haben wir in der ersten Zeile eine Array-Liste definiert. Dann haben wir für jede Schleife ein verwendet, um alle Werte des Arrays zu iterieren und zu drucken.

Innerhalb der Schleifenanweisung haben wir eine Ganzzahlvariable 'nmbr' deklariert, gefolgt vom Schlüsselwort 'in', auf das dann dasselbe des Arrays folgt. Wir wollen hier also sagen, dass wir nach einer Ganzzahl „nmbr“ in „list“ suchen.

Als nächstes ist die Anweisung ein einfacher Codeblock zum Drucken aller Werte. Wir drucken die Variable 'nmbr'. Wie bereits erwähnt, handelt es sich um eine schreibgeschützte Variable, die bei jeder Iteration einen neuen Wert speichert.

Schauen wir uns die Ausgabe zum besseren Verständnis an.

Ausgabe

Die in der Liste enthaltenen Nummern sind 1
Die in der Liste enthaltenen Nummern sind 2
Die in der Liste enthaltenen Nummern sind 3
Die in der Liste enthaltenen Nummern sind 4
Die in der Liste enthaltenen Nummern sind 5

Endlosschleife

Eine Schleife kann unendlich lange fortgesetzt werden, wenn die die Schleife definierende Bedingung niemals einen falschen Wert zurückgibt. Normalerweise kann eine for-Schleife oder eine while-Schleife verwendet werden, um eine Endlosschleifenoperation auszuführen.

Endlosschleife mit For-Schleife

Wir können 'for loop' verwenden, um eine Endlosschleifenoperation auszuführen, da keine der drei Anweisungen obligatorisch ist. Wenn wir also alle Anweisungen leer lassen, entsteht eine Endlosschleife.

/* for loop starts*/ for (; ;) { Console.WriteLine('infinite loop”); }

Diese Schleife druckt unendlich lange eine „Endlosschleife“ in der Konsole.

Die besten Seiten, um Anime kostenlos online zu sehen

Endlosschleife mit While-Schleife

Die while-Schleife kann auch zur Durchführung einer Endlosschleifenoperation verwendet werden. Wir können dies tun, indem wir eine Bedingung bereitstellen, die niemals falsch sein kann.

Zum Beispiel x> 0 und jedes Mal x erhöhen, beginnend mit 1.

/* while loop starts*/ int x = 1; while(x>0) { Console.WriteLine('infinite loop”); x++; }

Dadurch wird weiterhin eine Endlosschleife an die Konsole gedruckt, da der Wert von x immer größer als 1 bleibt. Daher gibt die while-Bedingung immer den Wert 'true' zurück, und der darin enthaltene Codeblock while wird weiterhin ausgeführt.

Fazit

Mit der Schleife können Sie einen Codeblock immer wieder durchlaufen. Die Programmiersprache C # bietet verschiedene Anweisungen für die Verwendung einer Schleife wie 'for', 'while', 'do while' und 'for each'.

Die while-Schleife führt einen Codeblock aus, solange der Ausdruck im while-Block wahr ist. Mit der Do While-Schleife kann der Benutzer einen Codeblock mindestens einmal ausführen. Anschließend wird die Iteration fortgesetzt, bis der darin enthaltene Ausdruck false zurückgibt.

Die for-Schleife wird verwendet, wenn wir bereits wissen, wie oft wir den Code iterieren müssen. Für jede Schleife wird jedes Element innerhalb einer Liste / Sammlung unter Verwendung eines bestimmten Codeblocks ausgeführt.

Normalerweise wird eine Schleife ausgeführt, bis der Steuerausdruck true zurückgibt. Die Anweisung continue oder break kann jedoch verwendet werden, um den Ausführungsfluss zu ändern.

Es ist auch möglich, Endlosschleifen mit for- oder while-Anweisungen zu erstellen, um einen Codeblock unendlich oft auszuführen. Diese Codeblöcke werden weiterhin ausgeführt, da der Ausdruck, der die Schleifenanweisung definiert, immer true zurückgibt.

=> Hier finden Sie den Easy C # Trainingsleitfaden

Literatur-Empfehlungen

^