C++-Programmierung/ Einführung in C++/ Schleifen

Mit dem, was Sie bis jetzt gelernt haben, sollte es für Sie eine leichte Übung sein, die Zahlen von eins bis zehn ausgeben zu lassen. So könnte ein Programm aussehen, das dies tut:

 1 #include <iostream>
 2 
 3 int main() {
 4     std::cout << "1\n";
 5     std::cout << "2\n";
 6     std::cout << "3\n";
 7     std::cout << "4\n";
 8     std::cout << "5\n";
 9     std::cout << "6\n";
10     std::cout << "7\n";
11     std::cout << "8\n";
12     std::cout << "9\n";
13     std::cout << "10\n";
14 }

Ausgabe:

 1 1
 2 2
 3 3
 4 4
 5 5
 6 6
 7 7
 8 8
 9 9
10 10

Dieses Programm ist einfach – aber was wäre, wenn die Zahlen eins bis einer Million ausgegeben werden sollen? Oder schlimmer noch – ja, es geht noch schlimmer: die Ausgabe hängt von der Benutzereingabe ab. Dann müssten Sie von der größtmöglichen Zahl ausgehen (bei unsigned int üblicherweise 4.294.967.295) und zusätzlich noch nach jeder Ausgabe überprüfen, ob die vom Benutzer eingegebene Zahl erreicht ist.

 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned i = 1;                  // 2 Variablen anlegen
 5     unsigned benutzer = 0;
 6 
 7     std::cin >> benutzer;            // Benutzer gibt Zahl ein
 8 
 9     if (i <= benutzer) {             // Benutzereingabe erreicht?
10         std::cout << "1\n";          // Ausgabe der Zahl 1
11         ++i;                         // Ausgegebene Zahlen mitzählen
12     } else {
13         return 0;                    // Anwendung beenden
14     }
15 
16     if (i <= benutzer) {             // Benutzereingabe erreicht?
17         std::cout << "2\n";          // Ausgabe der Zahl 2
18         ++i;                         // Ausgegebene Zahlen mitzählen
19     } else {
20         return 0;                    // Anwendung beenden
21     }
22 
23     // ...
24 
25     if (i <= benutzer) {             // Benutzereingabe erreicht?
26         std::cout << "4294967295\n"; // Ausgabe der Zahl 4294967295
27         ++i;                         // Ausgegebene Zahlen mitzählen
28     } else {
29         return 0;                    // Anwendung beenden
30     }
31 
32     // Wenn Ihr Compiler diese Stelle erreichen soll, brauchen Sie einen leistungsstarken
33     // Rechner und ein robustes Betriebssystem.
34     // Um dieses Problem zu lösen, setzen Sie sich einfach in die nächste Zeitmaschine
35     // und bestellen Sie sich einen Rechner aus dem Jahr 2020!
36 }

Insgesamt würden sich über 17,1 Milliarden Zeilen Code ergeben.

An diesem Punkt kommen Schleifen ins Spiel. Bis jetzt wurden alle Programme einfach der Reihe nach abgearbeitet und zwischendurch wurde eventuell mal verschiedenen Zweigen gefolgt. Mit einer Schleife können Sie erreichen, dass ein Programmteil mehrfach abgearbeitet wird. C++ stellt drei Schleifenkonstrukte zur Verfügung. Die kopfgesteuerte while-Schleife, die fußgesteuerte do-while-Schleife und die (ebenfalls kopfgesteuerte) for-Schleife. Was kopf- und fußgesteuerte Schleife bedeutet erfahren Sie in Kürze. Vielleicht wissen Sie es aber auch schon aus dem Kapitel „Grundlegende Elemente“, aus dem Abschnitt „Für Programmieranfänger“.

Die while-Schleife

Eine while-Schleife hat die folgende allgemeine Form:

Syntax:

while(«Bedingung») «Anweisung»

«Nicht-C++-Code», »optional«

Natürlich können Sie, wie bei den Verzweigungen auch, hier wieder mehrere Anweisungen zu einem Anweisungsblock zusammenfassen, da diese als eine Anweisung gilt:

Syntax:

while(«Bedingung») {
    «Anweisungen»
}

«Nicht-C++-Code», »optional«

Solange die Bedingung erfüllt ist, wird die Anweisung oder der Anweisungsblock ausgeführt. Da es sich hier um eine kopfgesteuerte Schleife handelt, wird erst die Bedingung ausgewertet. Ist diese erfüllt, so wird dann die Anweisung ausgeführt. Ist die nächste Überprüfung der Bedingung positiv, so wird der Schleifenrumpf erneut ausgeführt und so fort. Ist die Bedingung nicht erfüllt, wird der Schleifeninhalt übersprungen und mit dem Quelltext nach der Schleife fortgesetzt. Es kann daher vorkommen, dass der Schleifenrumpf gar nicht ausgeführt wird - wenn die Bedingung schon zu Beginn nicht erfüllt wird.

Was eine fußgesteuerte Schleife macht, erfahren Sie unter der Überschrift do-while. Eine Gegenüberstellung der beiden Schleifen gibt es in der Zusammenfassung dieses Kapitels.

Tipp

Wie Bedingungen ausgewertet werden, können Sie im Kapitel „Verzweigungen“ nachlesen - das vorherige Kapitel.

Hinweis

Beachten Sie, dass Schleifen so lange ausgeführt werden, bis die Bedingung nicht mehr erfüllt ist. Wenn Sie also nicht innerhalb der Schleife dafür sorgen, dass die Bedingung irgendwann nicht mehr erfüllt ist, dann haben Sie eine sogenannte Endlosschleife. Das heißt, der Schleifenrumpf (so nennt man die Anweisung oder den Anweisungsblock einer Schleife) wird immer wieder ausgeführt. Das Programm kann nur durch Abbrechen beendet werden. In Kombination mit einem Schlüsselwort, das Sie in Kürze kennen lernen werden, kann eine solche Endlosschleife durchaus gewollt und sinnvoll sein (der Befehl kann die Schleife abbrechen), aber in der Regel entsteht so etwas versehentlich. Wenn Ihr Programm also mal „abgestürzt“ ist, im Sinne von „Es reagiert nicht mehr! Wie schrecklich!“, dann haben Sie vermutlich irgendwo eine Endlosschleife eingebaut.

Nun aber zurück zu unserer Schleifenaufgabe mit 17,1 Milliarden Zeilen Code. Da Ihr Compiler immer noch nicht damit fertig ist, die oben vorgestellte Lösung zu übersetzen, versuchen wir jetzt mal das ganze mit einer while-Schleife zu lösen.

 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned i = 1;                  // 2 Variablen anlegen
 5     unsigned benutzer = 0;
 6 
 7     std::cin >> benutzer;            // Benutzer gibt Zahl ein
 8 
 9     while (i <= benutzer) {          // Benutzereingabe erreicht?
10         std::cout << i << std::endl; // Ausgabe von i und einem Zeilenumbruch
11         i++;                         // i um eins erhöhen (-> ausgegebene Zahlen mitzählen)
12     }
13 }

Nun ja, das sieht dem Programm von oben doch irgendwie ähnlich, nur die knapp 4,3 Milliarden if-Anweisungen sind weggefallen und haben einer vom Aufbau fast identischen while-Schleife Platz gemacht. Nun haben wir natürlich ein Problem: Ihr Superrechner aus dem Jahr 2020 ist immer noch mit der Übersetzung der ersten Programmversion beschäftigt und wird es wohl auch noch bis zu seiner Erfindung bleiben. Aber zum Glück haben Sie ja noch einen alten Rechner von 1980. Also versuchen Sie das Programm auf diesem zu übersetzen und auszuführen. Tatsächlich. Es funktioniert. Erstaunlich, dass so eine alte Kiste einen Rechner überholt, den Sie sich extra aus der Zukunft haben liefern lassen, um die maximale Leistungsstärke zu bekommen.

Wenn Sie Schwierigkeiten haben das Beispiel nachzuvollziehen, dann sehen Sie sich noch mal die Schleifen-Version für die Zahlen von 1 bis 10 an.

 1 #include <iostream>
 2 
 3 int main() {
 4     int i = 1;                       // Anlegen von i
 5 
 6     while (i <= 10) {                // Ist i noch kleiner-gleich 10?
 7         std::cout << i << std::endl; // Ausgabe von i und neue Zeile
 8         i++;                         // i um eins erhöhen
 9     }
10 }

Ausgabe:

 1 1
 2 2
 3 3
 4 4
 5 5
 6 6
 7 7
 8 8
 9 9
10 10

So sieht das Ganze schon viel kompakter und vielleicht auch übersichtlicher aus als die Version von ganz oben. Die Ausgabe dagegen ist völlig identisch. Hier wird i am Anfang auf eins gesetzt. Somit ist die Bedingung (eins ist kleiner oder gleich zehn) erfüllt. Damit wird der Schleifenrumpf ausgeführt. „1“ wird ausgegeben. Es folgt ein Zeilenumbruch. Danach wird der Wert von i um eins erhöht. Danach wird wieder geprüft, ob die Bedingung erfüllt ist. Da i jetzt zwei ist, lautet die Bedingung „zwei ist kleiner oder gleich zehn“, da dies eine wahre Aussage ist, wird wieder der Schleifenrumpf ausgeführt. Das wiederholt sich bis i Schließlich den Wert elf hat. Die Bedingung lautet dann „elf ist kleiner oder gleich zehn“, diese Aussage ist zweifellos falsch. Daher wird der Schleifenrumpf nun übersprungen und mit dem Code dahinter weitergemacht. Da in unserem Beispiel dort aber kein Code mehr folgt, wird das Programm beendet.

Zusammengefasst:

1. Quelltext vor der Schleife
2. Schleifen Bedingung
   • Erfüllt:
     1. Schleifenrumpf
     2. weiter mit 2
   • Nicht Erfüllt:
     1. weiter mit 3
3. Quelltext nach der Schleife

Die do-while-Schleife

Wie versprochen lüften wir nun das Geheimnis um die fußgesteuerten Schleifen. do-while ist eine fußgesteuerte Schleife, das heißt, als erstes wird der Schleifenrumpf ausgeführt, danach die Bedingung überprüft und dann abhängig von der Bedingung, wieder der Rumpf ausgeführt (Bedingung erfüllt) oder mit dem Quelltext nach der Schleife fortgesetzt (Bedingung nicht erfüllt). Eine fußgesteuerte Schleife zeichnet sich also dadurch aus, dass der Schleifenrumpf mindestens ein mal ausgeführt wird.

Syntax:

do «Anweisung» while(«Bedingung»);

«Nicht-C++-Code», »optional«

Bei dieser Schleife finden wir die obige Syntax nur selten, da der Schleifenrumpf hier zwischen den beiden Schlüsselwörtern do und while steht, wird fast immer ein Anweisungsblock benutzt, auch wenn nur eine Anweisung vorhanden ist. Für Ihren Compiler spielt das natürlich keine Rolle, aber für einen Menschen der den Quelltext liest, ist es übersichtlicher.

Syntax:

do{
    «Anweisungen»
} while(«Bedingung»);

«Nicht-C++-Code», »optional«

Unser anfängliches Riesenprogramm sieht mit einer do-while Schleife so aus:

 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned i = 1;                  // 2 Variablen anlegen
 5     unsigned benutzer = 0;
 6 
 7     std::cin >> benutzer;            // Benutzer gibt Zahl ein
 8 
 9     do {                             // Schleifenanfang
10         std::cout << i << std::endl; // Ausgabe von i
11         ++i;                         // Ausgegebene Zahlen mitzählen
12     } while (i <= benutzer);         // Benutzereingabe erreicht?
13 }

Sie werden feststellen, dass die Ausgabe dieses Programms mit der Ausgabe in der while-Schleifen Version übereinstimmt. Den Unterschied bemerken Sie, wenn Sie 0 eingeben: Während die while-Version keine Ausgabe macht, gibt diese do-while-Version „1“ und einen Zeilenumbruch aus, denn der Schleifenrumpf wird immer erst einmal ausgeführt, erst danach wird die Bedingung überprüft und entschieden ob er noch einmal ausgeführt werden muss.

Zusammengefasst:

1. Quelltext vor der Schleife
2. Schleifenrumpf
3. Schleifen Bedingung
   • Erfüllt: weiter mit 2
   • Nicht Erfüllt: weiter mit 4
4. Quelltext nach der Schleife

Die for-Schleife

Die for-Schleife ist etwas komplexer als die vorherigen beiden Schleifen. Sie gliedert sich in Teile:

Syntax:

for(«Initialisierungsteil»; «Bedingungsteil»; «Anweisungsteil») «Schleifenrumpf»

«Nicht-C++-Code», »optional«

Der Schleifenrumpf kann wie immer eine einzelne Anweisung oder ein {}-Anweisungsblock sein. Der Bedingungsteil verhält sich genau wie bei der while- und der do-while-Schleife oder sagen wir fast genau so, denn einen kleinen aber feinen Unterschied gibt es doch. Während while und do-while immer eine Bedingung erwarten, muss bei einer for-Schleife nicht unbedingt eine Bedingung angegeben werden. Wenn keine Bedingung angegeben ist, wird einfach angenommen, dass die Bedingung immer erfüllt ist, Sie erhalten eine Endlosschleife. Wie das sinnvoll eingesetzt wird erfahren Sie in Kürze.

Im Anweisungsteil können Sie eine beliebige Anweisung ausführen, dieser Teil wird oft verwendet, um Variablen bei jedem Schleifendurchlauf hoch oder runter zu zählen. Im nächsten Beispiel wird dies auch demonstriert. Es ist auch möglich, mehrere solcher „hoch- oder runter-Zähl“-Anweisungen durch Komma getrennt anzugeben, das wird im nächstem Beispiel aber nicht gemacht. Der Anweisungsteil wird übrigens direkt nach dem Schleifenrumpf und vor dem nächsten Bedingungstest ausgeführt. Der Initialisierungsteil ist dem Anweisungsteil dahingehend ähnlich, als dass auch hier eine beliebige Anweisung ausgeführt werden kann. Zusätzlich ist es hier aber noch möglich Variablen eines Datentyps anzulegen. Sie können also problemlos 2 int-Variablen anlegen, aber nicht eine int- und eine char-Variable. Der Initialisierungsteil wird nur einmal am Beginn der Schleife ausgeführt.

Thema wird später näher erläutert…

Im Kapitel Lebensdauer und Sichtbarkeit von Objekten werden Sie noch etwas genaueres darüber erfahren wo Sie die im Initialisierungsteil der Schleife angelegten Variablen verwenden können. Dort werden Sie auch erfahren wie eine for-Schleife mit Hilfe einer while-Schleife „nachgebaut“ werden kann.

Jetzt sollten Sie sich jedoch merken, dass Sie eine solche Variable nur innerhalb der Schleife verwenden können, also nicht mehr nach ihrem Verlassen.

 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned benutzer = 0;                   // Variablen für Benutzereingabe
 5 
 6     std::cin >> benutzer;                    // Benutzer gibt Zahl ein
 7 
 8     for(unsigned i = 1; i <= benutzer; ++i)  // for-Schleife
 9         std::cout << i << std::endl;         // Ausgabe von i
10 }

Zusammengefasst:

1. Quelltext vor der Schleife
2. Initialisierungsteil der Schleife
3. Schleifen Bedingung
   • Erfüllt:
     a) Schleifenrumpf
     b) Anweisungsteil
     c) weiter mit 3
   • Nicht Erfüllt: weiter mit 4
4. Quelltext nach der Schleife

Thema wird später näher erläutert…

Seit C++11 gibt noch eine weitere Form der for-Schleife. In vielen anderen Programmiersprachen nennt man diese Form die »foreach«-Schleife:

Syntax:

for(«Element»: «Container») «Schleifenrumpf»

«Nicht-C++-Code», »optional«

An dieser Stelle des Buches lässt sich die Funktionsweise noch schwer erklären, da die Datenstrukturen (welche hier mit «Container» angedeutet sind) noch nicht behandelt wurden. Daher wird erst später genauer auf diese Form der for-Schleife eingegangen.

Zu erkennen ist sie daran, das es keine zwei Semikolons zwischen den Klammern gibt, sondern einen Doppelpunkt.

Die break-Anweisung

Jetzt ist es an der Zeit, das Geheimnis um die sinnvolle Verwendung von Endlosschleifen zu enthüllen. Die break-Anweisung wird innerhalb von Schleifen verwendet, um die Schleife sofort zu beenden. Der Quelltext wird dann ganz normal nach der Schleife fortgesetzt. break können Sie in jeder der drei Schleifen verwenden. Das folgende Beispiel demonstriert den Einsatz von break, anhand unseres Lieblingsprogramms in diesem Kapitel.

 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned i = 1;                // 2 Variablen anlegen
 5     unsigned benutzer = 0;
 6 
 7     std::cin >> benutzer;          // Benutzer gibt Zahl ein
 8 
 9     for(;;){                       // Endlos-for-Schleife
10         std::cout << i << "\n";    // Ausgabe von i
11         ++i;                       // Variable erhöhen
12         if(i > benutzer) break;    // Abbrechen, wenn Bedingung erfüllt
13     }
14 }

Sie können aus jeder Schleife eine Endlosschleife machen, hier wurde die for-Schleife gewählt um zu zeigen wie Sie ohne Bedingung aussieht. Bei einer while- oder do-while-Schleife könnten Sie beispielsweise true als Bedingung angeben. Die for-Schleife legt jetzt übrigens das gleiche Verhalten an den Tag, wie eine do-while-Schleife. Sie können auch problemlos nur einen oder zwei Teile des Schleifenkopfes bei for-Schleife übergeben, wichtig ist nur, dass Sie die beiden Semikolons immer angeben, da Sie dem Compiler mitteilen, was welcher Teil des Schleifenkopfes ist.

Nun wissen Sie wieder etwas mehr über for, dabei sollte es unter dieser Überschrift doch eigentlich um break gehen. Wie Sie aber sehen, hängt letztlich alles mit allem zusammen und so ist es oft schwer eine richtige Abgrenzung zu schaffen.

Die continue-Anweisung

Das zweite wichtige Schlüsselwort für Schleifen ist continue. Es wird genau so verwendet wie break, bricht die Schleife allerdings nicht völlig ab, sondern setzt die Codeausführung am Ende des Schleifenrumpfes fort. Für while und do-while bedeutet das beim Bedingungstest, für die for-Schleife beim Anweisungsteil. Mit continue können Sie also den Rest des aktuellen Schleifendurchlaufs überspringen. Wir sehen uns das wieder anhand des Beispiels an.

 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned benutzer = 0;                    // Variablen für Benutzereingabe
 5 
 6     std::cin >> benutzer;                     // Benutzer gibt Zahl ein
 7 
 8     for(unsigned i = 1; i <= benutzer; ++i) { // for-Schleife
 9         if (i % 2 == 0) continue;             // alle geraden Zahlen überspringen
10         std::cout << i << std::endl;          // Ausgabe von i
11     }
12 }

Hier werden nur ungrade Zahlen ausgegeben, da der %-Operator (liefert den Rest einer Ganzzahligen Division) bei allen geraden Zahlen, (teilt man durch 2 ist als Rest ja nur 0 oder 1 möglich,) 0 zurückliefert und somit continue ausgeführt wird.

Natürlich könnten Sie das auch noch auf eine andere Weise realisieren. Aber es gibt ja beim Programmieren viele Wege, die nach Rom führen, wie in diesem Kapitel anhand der verschieden Schleifen schon bewiesen wurde. Leider gibt es aber noch mehr Wege, die auf direktem Wege an Rom vorbeiführen... Aber hier ist für das Beispiel von eben noch ein Pfad, der sicher nach Rom führt:

 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned int benutzer = 0;                 // Variablen für Benutzereingabe
 5 
 6     std::cin >> benutzer;                      // Benutzer gibt Zahl ein
 7 
 8     for(unsigned i = 1; i <= benutzer; i += 2) // for-Schleife mit 2er Schritten
 9         std::cout << i << std::endl;           // Ausgabe von i
10 }

Strukturierte Programmierung

Die Anweisungen 'break' und 'continue' gelten als „unsauber“, sie erschweren fast immer das Verständnis des Programms. Die Verwendung von 'break' ist oft ein Zeichen dafür, dass die Schleifenbedingung unvollständig ist - und man daher nicht einzig aus der Schleifenbedingung ersehen kann, wie lange die Schleife läuft. Die 'continue'-Anweisung kann meist durch eine 'if'-Anweisung ersetzt werden - oder ebenfalls durch eine exaktere Schleifenbedingung. In als „gut“ erachteten Programmen kommen 'break' und 'continue' möglichst gar nicht vor.

Kapitelanhang

Im Anhang zu diesem Kapitel finden Sie:

• Aufgaben und zugehörige Musterlösungen.

Aufgaben

Aufgabe 1: Schreiben Sie mithilfe einer Schleife ein kleines Spiel. Der Spielablauf lautet:

• Am Anfang gibt der Spieler einen Zahlenbereich ein. (Zum Beispiel: 1-100)
• Der Spieler muss sich innerhalb dieses Bereiches eine Zahl merken (eingegebene Grenzzahlen sind nicht zulässig).
• Das Programm soll dann die Zahl erraten. Der Benutzer teilt dem Programm mit, ob die Zahl an die er denkt kleiner, größer oder gleich der vom Programm geratenen Zahl ist. Die kann zum Beispiel über die Eingabe von <, > und = erfolgen.

Es gibt natürlich viele Wege dieses Problem zu lösen und Sie sehen ja ob Ihr Programm funktioniert oder nicht. Hier wird nur eine Musterlösung vorgestellt, falls Sie überhaupt nicht zurechtkommen oder sich einfach dafür interessieren wie der Autor an das Problem herangegangen ist.

 1 #include <iostream>
 2 
 3 int main() {
 4     int min, max; // Variablen für den möglichen Zahlenbereich
 5     int zahl;     // Zahl die der Rechner vermutet
 6 
 7     std::cout << "Wo fängt die Zahlenreihe an?: ";     // Zahlenbereich abfragen
 8     std::cin >> min;                                   // Benutzereingabe einlesen
 9 
10     std::cout << "Wo hört die Zahlenreihe auf?: ";     // Zahlenbereich abfragen
11     std::cin >> max;                                   // Benutzereingabe einlesen
12 
13     for (char eingabe = '0'; eingabe != '=';) {        // Abbrechen wenn eingabe '=' ist
14         zahl = min + (max - min) / 2;                  // Mittlere Zahl berechnen
15         std::cout << "Denken Sie an " << zahl << "? "; // Vermutung ausgeben
16         std::cin >> eingabe;                           // Antwort einlesen
17 
18         if (eingabe == '<')                        // Ist die Zahl kleiner?
19             max = zahl;                            // Setzte max auf den zu großen Wert zahl
20         else if (eingabe == '>')                   // Ist die Zahl größer?
21             min = zahl;                            // Setzte min auf den zu kleinen Wert zahl
22         else if (eingabe != '=')                   // Ist Eingabe auch kein Gleichheitszeichen
23             std::cout << "Sie haben ein unzulässiges Zeichen eingegeben!\n"; // Fehlerhafte Eingabe melden
24 
25         if (min+1 >= max) {                        // Keine Zahl mehr im gültigen Bereich
26             std::cout << "Sie sind ein Lügner!\n"; // Das Programm ist äußert entsetzt
27             break;                                 // Schleife wird abgebrochen
28         }
29     }
30 
31     std::cout << "Die von Ihnen gemerkte Zahl ist " << zahl << "!" << std::endl; // Ausgabe der erratenen Zahl
32 }

Ausgabe:

 1 Wo fängt die Zahlenreihe an?: 0
 2 Wo hört die Zahlenreihe auf?: 100
 3 Denken Sie an 50? <
 4 Denken Sie an 25? >
 5 Denken Sie an 37? <
 6 Denken Sie an 31? >
 7 Denken Sie an 34? <
 8 Denken Sie an 32? >
 9 Denken Sie an 33? =
10 Die von Ihnen gemerkte Zahl ist 33!

---

Dies ist eine Beispielausgabe, alles nach einem Fragezeichen ist eine Benutzereingabe.