Schleifen und Wiederholungen

Schleifen und Wiederholungen

Description: In diesem Video werden euch Schleifen bzw. Wiederholungen vorgestellt, die es euch ermöglichen, effizienter und übersichtlicher Code zu schreiben.

Duration: PT13M24S

ContentUrl: https://sec.ch9.ms/ch9/41dd/d915f355-362d-4c4a-8af8-b3cc8b2941dd/06SchleifenUndWiederholungen_mid.mp4

EmbedUrl: https://channel9.msdn.com/Series/Programmieren-fuer-Beginner-mit-C-/06-Schleifen-und-Wiederholungen/player

UploadDate: 2014-09-30T12:40:00+02:00

Thumbnail

Inhaltszusammenfassung

In diesem Beitrag geht es um Schleifen und Wiederholungen. Das heißt, dass ein bestimmter Programmteil mehrmals ausgeführt werden sollte, ohne dass man den Code mehrmals einfügt. Die WHILE-Schleife führt den Programmcode so lange aus, bis die Bedingung falsch ist. Beachte: Wenn die Bedingung nie falsch wird, endet der Code niemals, ergibt also eine Endlosschleife. Die FOR-Schleife ist der WHILE-Schleife sehr ähnlich, nur wird, statt dass eine Bedingung angegeben wird, festgelegt, wie oft die Schleife durchlaufen werden soll. Die Durchläufe werden in einer Zählervariable mitgezählt. Es wird vor jedem erneuten Durchlauf der Schleife überprüft, ob die Zählervariable immer noch kleiner (oder größer, wenn in die andere Richtung gezählt wird) ist, als der festgelegte Wert.


Durchführung

Warum Schleifen?

Durch ein Beispiel erklärt: Will man auf der Konsole die Zahlen 1 bis 100 ausgeben, würde man ohne Schleifen 100 Ausgaben schreiben müssen. Mit Schleifen gibt man 100-mal eine Variable aus, deren Wert man jedes Mal um eins erhöht. Programmieren wir das doch gleich in unserem Programm.


WHILE-Schleife

Der Aufbau der WHILE-Schleife:

while ( Bedingung ) { CODE }
Das bedeutet: solange die Bedingung in den runden Klammern richtig ist, wird der Code zwischen den geschwungenen Klammern ausgeführt. Mit unserem Beispiel würde das folgendermaßen aussehen:

class Program
{
static void Main(string[] args)
{
// While-Schleife
int i = 0;

while (i < 10)
{
Console.WriteLine(i);
i = i + 1;
}

Console.ReadLine();
}
}

In diesem Code wird zuerst eine Ganzzahl-Variable angelegt, die man in der Schleife jedes Mal um eins erhöht. Die Schleife läuft nur solange, bis diese Variable nicht mehr kleiner als 10 ist.


DO-WHILE-Schleife

Der Unterschied zwischen der WHILE-Schleife und der DO-WHILE-Schleife ist, dass der Code der WHILE-Schleife erst nach der Erfüllung der Bedingung ausgeführt wird. Das bedeutet, dass wenn die Bedingung von Beginn an falsch ist, der Code gar nicht ausgeführt wird. Bei der DO-WHILE-Schleife hingegen, wird erst der Code ausgeführt und danach erst die Bedingung überprüft. Das heißt, dass der Code mindestens (auch wenn die Bedingung von Anfang an falsch ist) einmal ausgeführt wird. Tritt dieser Spezialfall (Bedingung von Anfang an falsch) nicht auf, so ist das Ergebnis dasselbe.


Der Aufbau der DO-WHILE-Schleife:

do { CODE } while ( Bedingung );
Das Zahlenbeispiel würde in einer DO-WHILE-Schleife folgendermaßen aussehen:

class Program
{
static void Main(string[] args)
{
// do-While-Schleife
int i = 0;

do
{
Console.WriteLine(i);
i = i + 1;
} while (i < 10);
}
}

FOR-Schleife

Eine FOR-Schleife ist wie eine WHILE-Schleife, nur dass die Zählervariable in der Schleife schon eingebaut ist.
Beachte: Der Zugriff auf die Zählervariable kann nur innerhalb der FOR-Schleife erfolgen. Außerhalb kennt das Programm diese Variable nicht.


Der Aufbau der FOR-Schleife:
for (Zählervariable mit Startwert ; Abbruchbedingung ; Schrittweite )
Notiz: i = i + 1; kann auch folgendermaßen geschrieben werden:  i++; oder i += 1;
i += 1 ist bei FOR-Schleifen praktischer, da man nach dem Gleichzeichen nur die Schrittgröße eingibt.


Zahlenbeispiel mit FOR-Schleife:

class Program
{
static void Main(string[] args)
{
// for-Schleife
for (int n = 0; n < 100; n++)
{
Console.WriteLine(n);
}
}
}

Vollständiger Code für die Schleifen

class Program
{
static void Main(string[] args)
{
// While-Schleife
Console.WriteLine("WHILE-Schleife: ");
int i = 0;

while (i < 10)
{
Console.WriteLine(i);
i = i + 1;
}

// do-While-Schleife
Console.WriteLine("\nDO-WHILE-Schleife: "); // \n steht für Zeilenumbruch
i = 0;

do
{
Console.WriteLine(i);
i = i + 1;
} while (i < 10);

// for-Schleife
Console.WriteLine("\nFOR-Schleife: ");

for (int n = 0; n < 100; n++)
{
Console.WriteLine(n);
}

Console.ReadLine();
}
}

Beispiel für die Anwendung einer Schleife

class Program
{
static void Main(string[] args)
{
int i = 110214321;
int zaehler = 0;
while (i > 0)
{
i = i - 11;
zaehler++;
}
Console.WriteLine("Die Zahl 11 ist " + zaehler + " Mal in 110214321 enthalten");

Console.ReadLine();
}
}