int f( int m, int n ) { if ( n < 0 ) return -n; else if ( n > 0 ) return n; else return m; }
Wiederholungen
Die Kontrollstruktur der Wiederholung wird verwendet, wenn eine Anweisung oder Anweisungsfolge mehrere Male ausgeführt werden soll. Es lassen sich verschiedenste Formen der Wiederholung unterscheiden, wobei die while-Schleife die einfachste Form ist; in ihr wird eine Anweisung einfach so lange wiederholt, bis eine bestimmte Bedingung nicht mehr gilt. Das sieht in C++ dann zum Beispiel so aus:
int sum( int n ) { int s = 0; while ( n > 0 ) { s = s + n; n = n - 1; } return s; }
Die Funktion sum macht hierbei nichts anderes als die Summe der Zahlen von 1 bis n (oder, um den Programmablauf besser sprachlich abzubilden: von n bis 1) zu berechnen. Die Schleife wird dabei so oft durchlaufen, wie die Variable n einen Wert größer als 0 besitzt; in jedem Durchlauf wird das aktuelle n auf den Wert von s addiert und n um eins verringert. Denkbar einfach also.
Eine zweite, häufig anzutreffende Wiederholung in C++-Code ist die Zählschleife oder for-Schleife. Diese erlaubt (unter anderem), eine Schleife eine festgelegte Anzahl von Malen zu durchlaufen. Zu diesem Zweck wird eine Laufvariable definiert und für diese der Startwert, der Endwert (in Form einer Bedingung) und die Schrittweite (in Form eines Ausdruckes) angegeben. Die Summen-Funktion lässt sich damit auch folgendermaßen schreiben:
int sum( int n ) { int s = 0; for ( int i = 1; i <= n; i = i + 1 ) s = s + i; return s; }
In Worten besagt die Schleife folgendes: deklariere eine Variable i (die übrigens nur innerhalb der Schleife gültig ist) und weise ihr den Wert 1 zu; solange i kleiner oder gleich n ist (<= ist der C++-Operator für ≤), führe die Anweisungen in der Schleife aus und erhöhe am Ende jedes Durchlaufes i um 1.
Neben der while- und for-Schleife gibt es noch die do-while-Schleife, die ähnlich wie die while-Schleife funktioniert, die Bedingung aber am Ende eines Schleifendurchlaufes und nicht am Anfang prüft; einziger Unterschied zur while-Schleife ist damit, dass die Anweisungen in der Schleife wenigstens ein mal auf jeden Fall ausgeführt werden - unabhängig von der Bedingung. Geschrieben wird sie so:
int sum( int n ) { int s = 0; do { s = s + n; n = n - 1; } while ( n > 0 ); return s; }
Beim Verwenden von Schleifen ist auf eine Tücke zu achten: wird nicht sichergestellt, dass die Bedingung einer Schleife irgendwann nicht mehr gilt, kann man in eine sogenannte unendliche Schleife geraten, also eine Schleife, die niemals endet und immer wieder durchlaufen wird - was dazu führt, dass ein Programm nicht mehr reagiert und/oder abstürzt.
Zwei Konzepte sind bei der Verwendung von Schleifen noch interessant: das vorzeitige Abbrechen einer Schleife und das vorzeitige Abbrechen des aktuellen Schleifendurchlaufes.
Der vorzeitige Abbruch der gesamten Schleife erfolgt mit Hilfe des Schlüsselwortes break; wird es im Schleifenkörper angetroffen, so wird die Schleife sofort abgebrochen. Hier ein kleines Beispiel einer Summen-Schleife, die abbricht, sobald die berechnete Summe einen Wert größer als 1000 erreicht:
int sum1000( int n ) { int s = 0; while ( n > 0 ) { s = s + n; n = n - 1; if ( s > 1000 ) break; } return s; }
Mit Hilfe des Schlüsselwortes continue kann dagegen lediglich der aktuelle Schleifendurchlauf abgebrochen werden; wird es angetroffen, beginnt die Schleife sofort mit dem nächsten Durchlauf. Das folgende Beispiel zeigt eine Schleife, welche lediglich gerade Zahlen aufsummiert (der %-Operator ist der Restwert-Operator, der den Rest einer ganzzahligen Division zurückgibt):
Kommentare (23)