Du bist hier: Startseite > Entwicklung (C/C++) > C++ Grundlagen > Schleifen und Kontroll- Transferanweisungen

Schleifen und Kontroll- Transferanweisungen

Während mit Hilfe einer if-Kontrollstruktur unterschiedlicher Code genau einmal ausgeführt werden kann, kann mit Schleifen Code in Abhängigkeit einer Bedingung wiederholt ausgeführt werden. C++ stellt verschiedene Schleifentypen zur Verfügung.

Die while Schleife

Eine while-Schleife ist ähnlich wie eine if-Kontrollstruktur aufgebaut: Zuerst kommt das Schlüsselwort, in diesem Fall while, danach wird in runden Klammern eine Bedingung überprüft, dahinter folgt zwischen geschweiften Klammern ein Anweisungsblock. Abhängig von der Bedingung wird der Anweisungsblock ausgeführt, oder aber die Code-Ausführung setzt hinter dem Anweisungsblock fort.

Im Gegensatz zum if wird jedoch nach einem Durchlauf des Anweisungsblocks die Bedingung in runden Klammern erneut überprüft. Ist sie wieder true, wird der Anweisungsblock nochmal durchlaufen. Auch nach diesem Durchlauf findet erneut eine Überprüfung der Bedingung statt mit eventuell anschließendem erneuten Durchlauf des Anweisungsblocks. Dieses Spielchen wiederholt sich solange, bis die zu überprüfende Bedingung false ergibt. Erst dann wird der Anweisungsblock übersprungen und das Programm danach fortgesetzt.

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2. #include <stdlib.h> // EXIT_SUCCESS
  3.  
  4. int main(void)
  5. {
  6. 	int i = 0;
  7. 	while ( i < 10 )
  8. 	{
  9. 		std::cout << i << std::endl;
  10. 		i++;
  11. 	}
  12.  
  13. 	std::cin.get();
  14. 	return EXIT_SUCCESS;
  15. }

Die do while Schleife

Im Gegensatz zu einer while-Schleife findet bei einer do-while-Schleife die Überprüfung der Bedingung am Ende eines Schleifendurchgangs statt. Das bedeutet, dass der Anweisungsblock (do) der Schleife auf alle Fälle einmal ausgeführt wird. Erst nach dieser einmaligen Ausführung wird entschieden, ob die Schleife nochmal durchlaufen werden muss. Während in einer while-Schleife zuerst die Bedingung und dann die Schleife ausgeführt wird, wird in einer do-while-Schleife zuerst die Schleife durchlaufen und dann die Bedingung überprüft.

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2. #include <stdlib.h> // EXIT_SUCCESS
  3.  
  4. int main(void)
  5. {
  6. 	int i = 0;
  7. 	do
  8. 	{
  9. 		std::cout << i << std::endl;
  10. 		i++;
  11. 	} while ( i < 10 );
  12.  
  13. 	std::cin.get();
  14. 	return EXIT_SUCCESS;
  15. }

Die for Schleife

Die for-Schleife ist ähnlich aufgebaut wie die while-Schleife: Zuerst wird das Schlüsselwort gesetzt, dann folgt eine runde Klammer, danach folgt der Anweisungsblock der Schleife. Im Gegensatz zur while-Schleife besteht die runde Klammer jedoch in einer for-Schleife nicht mehr nur aus der Überprüfung einer Bedingung, sondern aus drei verschiedenen Bereichen.

Eine for-Schleife unterteilt die runde Klammer in genau drei Bereiche. Zur Abgrenzung der Bereiche werden Semikolons gesetzt. Der erste Bereich - von der geöffneten runden Klammer zum ersten Semikolon - ist der Initialisierungsbereich. Der zweite Bereich - vom ersten Semikolon zum zweiten Semikolon - ist die Schleifenbedingung. Der dritte Bereich - vom zweiten Semikolon zur geschlossenen runden Klammer - ist die Wertänderung.

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2. #include <stdlib.h> // EXIT_SUCCESS
  3.  
  4. int main(void)
  5. {
  6. 	for ( int i=0; i < 10; i++ )
  7. 	{
  8. 		std::cout << i << std::endl;
  9. 	}
  10.  
  11. 	std::cin.get();
  12. 	return EXIT_SUCCESS;
  13. }

Kontrolltransferanweisungen

In C++ stehen zwei Schlüsselwörter zur Verfügung, um eine laufende Code-Ausführung abzubrechen oder neu zu starten. Ein Schlüsselwort hast du bereits kennengelernt: break.

Mit break können nicht nur switch-case-Kontrollstrukturen beendet werden, sondern auch alle Schleifentypen.

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2. #include <stdlib.h> // EXIT_SUCCESS
  3.  
  4. int main(void)
  5. {
  6. 	int i = 0;
  7. 	while (i < 10)
  8. 	{
  9. 		std::cout << i << std::endl;
  10. 		i++;
  11. 		if (i >= 5)
  12. 		{
  13. 			break;
  14. 		}
  15. 	}
  16.  
  17. 	std::cin.get();
  18. 	return EXIT_SUCCESS;
  19. }

Übrigens: Wenn eine while Schleife in einer while Schleife läuft, und anstatt "break" "break 2" aufgerufen wird, dann werden beide Schleifen beendet!

Das zweite Schlüsselwort, das in die Kategorie Kontrolltransferanweisungen fällt, ist continue. Betrachte hierzu folgendes Beispiel.

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2. #include <stdlib.h> // EXIT_SUCCESS
  3.  
  4. int main(void)
  5. {
  6. 	int i = 0;
  7. 	while (i < 10)
  8. 	{
  9. 		i++;
  10. 		if (i == 5)
  11. 		{
  12. 			continue;
  13. 		}
  14. 		std::cout << i << std::endl;
  15. 	}
  16.  
  17. 	std::cin.get();
  18. 	return EXIT_SUCCESS;
  19. }

Das Schlüsselwort continue sorgt im obigen Beispiel dafür, dass ein neuer Schleifendurchgang begonnen wird, sobald in der Variable i die Zahl 5 steht.

Kommentare zu diesem Beitrag

Sie müssen angemeldet sein, um eine Nachricht zu erstellen. Anmelden »