Schleifen (for; while; do-while; foreach)
In C# gibt 4 verschiedene Schleifen. Alle 4 kann man ständig gebrauchen, deshalb ist es ein wichtiges Thema ^^
Zu Beginn erst einmal das Wort
break. Es wird in allen Schleifen dazu verwendet, die Schleife sofort zu beenden.
Wenn wir in einer Schleife also schreiben
break; dann wird an dieser Stelle die Schleife abgebrochen.
Jetzt weiter mit den Schleifen:
FOR-Schleife
Die For-Schleife ist eine Zähl-Schleife. Sie zählt von einer Start-Zahl bis zu einem bestimmten Ende und zählt dabei in den fest gelegten Schritten. Ein nützliches Teil und so wird sie geschrieben:
Code:
[COLOR="#0000FF"]for[/COLOR] ([COLOR="#0000FF"]int[/COLOR] i = START; i <= ENDE; i++)
{
}
Wenn ich das einmal mit einer Wort-Definition zeige:
VON (ZAHLENTYP INDEX = START; INDEX <= ENDE; INTERVALL)
{
}
In der Schleife wird im Prinzip eine neue Variable erstellt.
Ganz am Anfang in den runden Klammern steht der Datentyp. Dieser Datentyp muss ein nummerischer Typ sein, also merkt euch einfach fürs Erste int und double. Ich persönlich habe double noch nie benutzt, das kann jeder halten, wie er möchte.
Diese Variable vekommt einen Namen. Standartmäßig ist dieser Name i für Index, aber der kann im grunde frei gewählt werden.
Darauf folgt dann ein Semikolon, das angibt, dass die Variable fertig definiert wurde.
Dahinter folgt dann eine Bedingung, wie wir sie schon von der If-Abfrage kennen. Und tatsächlich, dort kann man auch einfach true rein schreiben, doch das ist nicht Sinn und Zweck dieser Schleife.
Die Schleife zählt also einfach nur solange, wie in der Bedingung true raus kommt.
Wenn wir also wollen, dass die Zahlen 1, 2, 3, 4 und 5 gezählt werden sollen, muss in der Bedingung stehen
i<=5
Das heist, die Schleife zählt so lange, bis i entweder kleiner als 5 ist, oder gleich.
Diese Bedingung kann nun frei gestellt werden, aber zum zählen reicht das aus.
Und auch hier hinter folgt ein Semikolon, das angibt, dass die Bedingung zuende ist.
Als letztes folgt das Intervall. Als Standart steht dort immer
i++. Das heist, dass i immer um eines erhöht wird. Wenn ihr i-- schreibt, dann wird i immer um eins verringert.
Ihr könnt dort auch eine ganze Rechnung eingeben, wie wir sie schon kennen.
Als Beispiel:
i = i + 2
Das zählt immer zwei auf i dazu, also zählt die Schleife in Zweier-Schritten.
Gut, damit ist die Scheife auch beendet. Vorne wird die Variable, mit der gezählt wird, fest gelegt, danach die Bedingung, die angibt, wie lange gezählt wird und als letztes die Rechnung, die das Intervall bestimmt.
Und hier haben wir auch unsere Schleife:
Code:
[COLOR="#0000FF"]for[/COLOR] (int i = 1; i <= 5; i++)
{
[COLOR="#00FFFF"]Console[/COLOR].WriteLine(i);
}
[COLOR="#00FFFF"]Console[/COLOR].ReadLine();
Hier wurde nun eine Schleife erstellt, die von 1 bis 5 zählt. Immer, wenn eins weiter gezählt wird, wird der Befehlsblock zwischen den geschweiften Klammern ausgeführt. Hier ist es wieder unsere Konsolen-Anweisung, die i in die Konsole schreibt.
Wenn ihr das in ein Programm einfügt, werdet ihr sehe, dass dort 1, 2, 3, 4 und 5 untereinander aufgelistet wurde.
Wenn ihr das Intervall auf 2 setzt (i = i + 2), dann wird dort nur 3 und 5 stehen, denn 1 + 2 = 3 und 3 + 2 = 5.
Wenn wir jetzt theoretisch betrachten, was in der Schleife passiert:
i wird als Variable von Typ int mit dem Startwert 1 fest gelegt.
Mit i wird nun die Rechnung am Ende des SChleifenkopfes ausgeführt. Wenn dort i = i + 2 steht, wird i + 2 gerechnet.
Dann wird überprüft, ob die Bedingung noch erfüllt wird. Unsere Zahl ist nun 3. Die 3 ist kleiner, als 5, also wird der Befehlsblock ausgeführt. Die 3 wird also hin geschrieben.
Dann folgt wieder die Rechnung. Wieder 2 auf i zählen, in diesem Fall jetzt 3 + 2 = 5.
Wir überprüfen: 5 ist nicht mehr kleiner als 5, aber wir haben ja fest gelegt, dass i kleiner
oder gleich sein darf. Und 5 ist gleich 5, also wird der Befehlsblock ausgeführt.
Es wird wieder die Rechnung ausgeführt, also 5 + 2 = 7
Die Überprüfung ergibt, dass 7 größer als 5 ist, also wird sie nicht erfüllt, wenn es hies ja kleiner oder gleich 5.
Da die Bedingung nicht erfüllt wurd, wird die Schleife beendet, ohne dass der Befehlsblock noch einmal ausgeführt wird.
while-Schleifen
Wer Englisch zumindest ein bisschen kann, und das sollte man bei der Programmierung, (zur Not tuts auch der Google-Übersetzer^^) wird fest stellen, dass while einfach nur während bedeutet.
Und wie in der englischen Grammatik folgt auf das während eine Bedingung.
Also sieht das als Schema so aus:
WÄHREND (BEDINGUNG)
{
}
In der Bedingung kommen wieder solche Bedingungen, wie die, die wir von If kennen.
Das Programm prüft erst mal, ob die Bedingung erfüllt wird und führt dann so lange den Inhalt der geschweiften Klammern aus, bis die Bedingung nicht mehr erfüllt wird.
Das kann z.B. der Fall sein, wenn eine Variable, die in der Bedingung enthalten ist, sich ändert, während die Schleife im Gang ist.
Eine einfache Endlos-Schleife ist dann die hier:
Code:
[COLOR="#0000FF"]while[/COLOR] ([COLOR="#0000FF"]true[/COLOR])
{
}
Das würde ich allerdings nicht empfehlen, außer man bricht die Schleife von innen heraus mit
break ab.
Als Beispiel nehme ich mal einen ganz einfachen Taschenrechner. Den Code brauchen wir nicht, wir brauche nur das, was der Nutzer eingibt.
Wenn es also ein kleines Menü gibt und dort wird aufgefordert, die Nummer eines Menü-Eintrages zu schreiben und zu bestätigen (wir erinnern und an Console.ReadLine() -> Gibt alles aus, was eingegeben wurde, bevor Enter gedrückt wurde).
Wenn die Menüs also die Nummern 1, 2 oder 3 haben und 0 zum Beenden, dann müssen wir schauen, dass auch passiert.
Und das passiert am besten mit der switch-Anweisung, doch dazu später noch mehr.
Viel wichtiger ist, dass überprüft wird, ob die Eingabe auch korrekt ist. Wenn nämlich ein Buchstabe eingegeben wurde, was soll das Programm dann tun? Abstürzen, aus den Augen aus dem Sinn?
Nein, es wird einfach noch mal zur Eingabe aufgefordert.
Code:
[COLOR="#0000FF"]string[/COLOR] eingabe;
[COLOR="#0000FF"]while[/COLOR] ([COLOR="#0000FF"]true[/COLOR])
{
[COLOR="#008000"] // Hier steht die Aufforderung, ein Menü zu wählen.
// "eingabe" wird beschrieben, durch den Nutzer[/COLOR]
[COLOR="#0000FF"]if[/COLOR] ([COLOR="#008000"]/*Überprüft, ob "eingabe" korrekt ist.*/[/COLOR])
{
[COLOR="#0000FF"]break[/COLOR]; [COLOR="#008000"]//Die Schleife wird beendet und so kann ein korrektes "eingabe" später weiter verwendet werden[/COLOR]
}
[COLOR="#0000FF"]else[/COLOR]
{
[COLOR="#008000"] // Da die Eingabe falsch ist, muss eine richtige Eingabe abgefragt werden.
// Dazu geben wir erst mal einen kleinen Fehler aus und brechen die Schleife nicht ab
// Denn die Schleife beginnt gleich wieder von vorne, fragt nach der Eingabe, überprüft sie und reagiert entsprechend[/COLOR]
}
}
Das ist die While-SChleife und die umkehrung dazu ist die Do-While-Schleife.
do-while-Schleifen
Diese Schleife macht das etwas anders, als die while-Schleife.
Sie tut erst das, was zwischen ihren Klammern steht und danach überprüft sie.
Sobald dann der Befehlsblock einmal ausgeführt wurde und dann die Bedingung geprüft wurde, geht es ganz normal so weiter, wie bei der while-Schleife.
Und so wird sie geschrieben:
Code:
[COLOR="#0000FF"]do[/COLOR]
{
[COLOR="#008000"]// Das hier wird einmal ohne Überprüfimg ausgeführt und dann nur noch, wenn die Überprüfung positiv war[/COLOR]
}
[COLOR="#0000FF"]while[/COLOR] ([COLOR="#0000FF"]true[/COLOR]);
[COLOR="#008000"]//Nun ist "eingabe" richtig und kann verwendet werden um die richtige Methode auszuwählen, je nachdem, was den Nutzer eingegeben hat.[/COLOR]
Das kann man z.B. für unser Taschenrechner-Problem nutzen:
Code:
[COLOR="#0000FF"]bool[/COLOR] richtig;
[COLOR="#0000FF"]do[/COLOR]
{
[COLOR="#008000"]// Das hier wird einmal ohne Überprüfimg ausgeführt und dann nur noch, wenn die Überprüfung positiv war
// Die erste Eingabe wird einfach ausgeführt. Danach wird überprüft, ob die Eingabe korrekt ist und in "richtig" gespeichert.
// Die Bedingung besteht nun aus dieser Variable.[/COLOR]
}
[COLOR="#0000FF"]while[/COLOR] (!richtig);
In der Bedingung habe ich vor die Variable ein Ausrufezeichen geschrieben um die Bedeutung umzukehren.
Denn wenn bei einer falschen Eingabe false gespeichert wird, würde das die Schleife beenden
Nun wird in der Bedingung true benötigt um die Schleife zu beenden, denn wenn dort true steht, wird die Bedeutung umgekehrt, also sieht das Programm dort ein false und beendet die Schleife.
Nun ist "eingabe" richtig und kann verwendet werden um die richtige Methode auszuwählen, je nachdem, was den Nutzer eingegeben hat.[/CODE]
foreach-Schleife
Eine foreach-Schleife durchläuft alle gegebenen Elemente und beendet sich, sobald keine Elemente mehr gegeben sind.
Sie arbeitet mit allen Variablen, die mehr als eine Bedeutung tragen können, wie z.B. Listen oder Felder (Arrays).
Diese Dinge werde ich später noch erklären.
Hier eine kurze Beschreibung, wie eine foreach-Schleife verwendet wird:
foreach (Datentyp ItemName in VariablenName)
{
}
In dieser Schleife wird wieder eine Variable erstellt. Sie bekommt den Namen an der Stelle von ItemName und hat den Datentyp, der davor angegeben wird. Hinter dem "in" steht der Variablenname der Liste oder von dem Feld.
(Listen oder Felder sind Sammlungen von Elementen mit dem selben Datentyp)
Der Datentyp der in der Schleife erstellten Variable muss der Selbe sein, wie der Datentyp von den Elementen der Liste oder des Feldes.
Die Schleie geht nun alle Elemente der Liste oder des Feldes nacheinander durch und stellt dieses Element unter dem Namen der Variable, die in der Schleife erstellr wurde, einmal zur Verfügung, bis die Schleife das nächste Element aufruft.