• Einführung in Schleifen
• Die while-Schleife
• Die do-while-Schleife
• Die For-Schleife
• Die break-Anweisung
• Die continue-Anweisung
• Strukturierte Programmierung
• Beispielprogramm: Zahl erraten
• Häufige Fragen

Einführung in Schleifen

In der Programmierung spielt die Verwendung von Schleifen eine essentielle Rolle. Schleifen ermöglichen es, bestimmte Codeblöcke wiederholt auszuführen, solange bestimmte Bedingungen erfüllt sind. Dadurch können wiederkehrende Aufgaben automatisiert und effizient erledigt werden. In diesem Einführungstutorial werden wir uns mit den verschiedenen Arten von Schleifen in C++ befassen und ihre Funktionsweise näher betrachten.

Die while-Schleife

Die while-Schleife ist die einfachste Form einer Schleife in C++. Sie wiederholt einen Codeblock, solange eine bestimmte Bedingung wahr ist. Die Bedingung wird am Anfang jeder Iteration überprüft und wenn sie wahr ist, wird der Codeblock ausgeführt. Wenn die Bedingung jedoch falsch ist, wird das Programm den Codeblock überspringen und mit der Ausführung des nachfolgenden Codes fortsetzen.

Die while-Schleife besteht aus dem Schlüsselwort "while", gefolgt von einer runden Klammer, in der die Bedingung angegeben wird. Danach folgt der Codeblock, der in geschweiften Klammern eingeschlossen ist. Innerhalb des Codeblocks können beliebige Anweisungen stehen, die wiederholt ausgeführt werden sollen.

Ein Beispiel für die Verwendung einer while-Schleife könnte das Ausgeben von Zahlen von 1 bis 10 sein:

int i = 1;
while (i <= 10) {
cout << i << " ";
i++;
}


Die do-while-Schleife

Die do-while-Schleife funktioniert ähnlich wie die while-Schleife. Der Unterschied besteht darin, dass die Bedingung am Ende jeder Iteration überprüft wird, sodass der Codeblock mindestens einmal ausgeführt wird, selbst wenn die Bedingung von Anfang an falsch ist.

Die do-while-Schleife beginnt mit dem Schlüsselwort "do", gefolgt vom Codeblock in geschweiften Klammern. Danach folgt das Schlüsselwort "while" mit der Bedingung in einer runden Klammer.

Ein Beispiel für die Verwendung einer do-while-Schleife könnte die Eingabe einer Zahl durch den Benutzer sein, die größer als 10 sein muss:

int num;
do {
cout << "Bitte gib eine Zahl größer als 10 ein: ";
cin >> num;
} while (num <= 10);


Die for-Schleife

Die for-Schleife ist eine erweiterte Form der Schleife in C++. Sie vereint die Bedingung, die Initialisierung und die Iteration in einer einzigen Zeile. Die for-Schleife wird häufig verwendet, wenn man die Anzahl der Iterationen im Voraus kennt.

Die for-Schleife besteht aus dem Schlüsselwort "for", gefolgt von runden Klammern. In der ersten Klammer wird die Initialisierung durchgeführt, in der zweiten Klammer wird die Bedingung angegeben, und in der dritten Klammer wird die Iteration definiert. Zwischen den Klammern stehen Semikolons.

Ein Beispiel für die Verwendung einer for-Schleife könnte das Berechnen der Summe der ersten 10 natürlichen Zahlen sein:

int sum = 0;
for (int i = 1; i <= 10; i++) {
sum += i;
}


Die break-Anweisung

Die break-Anweisung wird verwendet, um eine Schleife vorzeitig zu beenden, auch wenn die Bedingung noch erfüllt ist. Wenn die break-Anweisung erreicht wird, springt das Programm aus der Schleife heraus und setzt die Ausführung nach der Schleife fort.

Ein Beispiel für die Verwendung der break-Anweisung könnte das Durchsuchen eines Arrays nach einem bestimmten Wert sein. Sobald der Wert gefunden wird, wird die Schleife mit break beendet:

int numbers[] = {1, 2, 3, 4, 5};
int searchValue = 3;
for (int i = 0; i < 5; i++) {
if (numbers[i] == searchValue) {
cout << "Der Wert wurde gefunden.";
break;
}
}


Die continue-Anweisung

Die continue-Anweisung wird verwendet, um den aktuellen Schleifendurchlauf vorzeitig zu beenden und mit dem nächsten Durchlauf fortzufahren. Wenn die continue-Anweisung erreicht wird, werden alle nachfolgenden Anweisungen innerhalb des aktuellen Durchlaufs übersprungen, und die nächste Iteration beginnt.

Ein Beispiel für die Verwendung der continue-Anweisung könnte das Überspringen von bestimmten Zahlen in einer Schleife sein, z.B. das Überspringen aller geraden Zahlen:

for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) {
continue;
}
cout << i << " ";
}


Die continue-Anweisung sorgt dafür, dass die Zahl übersprungen wird, wenn sie gerade ist.

Die Verwendung von Schleifen ist grundlegend für die strukturierte Programmierung in C++. Durch die Anwendung von while-Schleifen, do-while-Schleifen und for-Schleifen kann Code effizienter und lesbarer gestaltet werden. Die break- und continue-Anweisungen ermöglichen zusätzliche Kontrolle über den Ablauf innerhalb von Schleifen.

Die while-Schleife

In C++ gibt es verschiedene Arten von Schleifen, die verwendet werden können, um bestimmte Codeblöcke wiederholt auszuführen. Eine häufig verwendete Schleifenart ist die while-Schleife. Mit dieser Schleife kann ein Codeblock solange wiederholt werden, wie eine bestimmte Bedingung erfüllt ist.

Syntax der while-Schleife

Die while-Schleife hat eine einfache Syntax. Sie beginnt mit dem Schlüsselwort "while", gefolgt von einer runden Klammer, in der die Bedingung angegeben wird. Nach der Klammer folgt der Codeblock, der in geschweiften Klammern eingeschlossen ist.

cpp
while (Bedingung)
{
// Codeblock, der wiederholt ausgeführt wird
}


Funktionsweise der while-Schleife

Bei Ausführung der Schleife wird zuerst die Bedingung überprüft. Wenn die Bedingung wahr ist, wird der Codeblock ausgeführt. Nach der Ausführung des Codeblocks wird die Bedingung erneut überprüft. Solange die Bedingung wahr ist, wird der Codeblock wiederholt ausgeführt. Sobald die Bedingung falsch ist, wird die Schleife beendet und die Ausführung des Programms wird fortgesetzt.

Es ist wichtig sicherzustellen, dass die Bedingung innerhalb der Schleife angepasst wird, damit die Schleife nicht in eine Endlosschleife gerät. Eine Endlosschleife tritt auf, wenn die Bedingung immer wahr ist und die Schleife nie beendet wird.

Beispiel für die Verwendung der while-Schleife

Ein Beispiel für die Verwendung der while-Schleife ist das Ausgeben von Zahlen von 1 bis 5. Wir können eine Variable initialisieren und dann in jedem Durchlauf den Wert um 1 erhöhen, um schließlich die gewünschte Anzahl an Durchläufen zu erreichen.

cpp
int i = 1; // Initialisierung
while (i <= 5) // Bedingung
{
cout << i << " "; // Ausgabe der Zahl
i++; // Inkrementierung des Zählers
}


Das obige Beispiel wird die Zahlen 1, 2, 3, 4 und 5 ausgeben.

Vorteile der while-Schleife

Die while-Schleife bietet eine flexible Möglichkeit zum wiederholten Ausführen von Code, da die Bedingung auf verschiedene Arten modifiziert werden kann. Solange die Bedingung wahr ist, wird der Codeblock ausgeführt, was bei der Implementierung bestimmter Aufgaben sehr hilfreich sein kann.

Fazit

Die while-Schleife ist eine wichtige Schleifenart in der C++-Programmierung. Sie bietet die Möglichkeit, einen Codeblock solange zu wiederholen, wie eine bestimmte Bedingung erfüllt ist. Mit der richtigen Verwendung der Bedingung und der Aktualisierung von Variablen kann die while-Schleife eine effiziente Möglichkeit sein, wiederkehrende Aufgaben umzusetzen.

Die do-while-Schleife

Die do-while-Schleife ist eine Schleifenart in C++, die ähnlich wie die while-Schleife funktioniert. Der Hauptunterschied besteht darin, dass die Bedingung am Ende jeder Iteration überprüft wird, sodass der Codeblock mindestens einmal ausgeführt wird, selbst wenn die Bedingung von Anfang an falsch ist.

Syntax der do-while-Schleife

Die do-while-Schleife hat eine leicht abweichende Syntax im Vergleich zur while-Schleife. Sie beginnt mit dem Schlüsselwort "do", gefolgt vom Codeblock in geschweiften Klammern. Danach folgt das Schlüsselwort "while" mit der Bedingung in runden Klammern.

cpp
do
{
// Codeblock, der mindestens einmal ausgeführt wird
}
while (Bedingung);


Funktionsweise der do-while-Schleife

Bei der Ausführung der Schleife wird zuerst der Codeblock ausgeführt. Danach wird die Bedingung überprüft. Wenn die Bedingung wahr ist, wird der Codeblock erneut ausgeführt. Dieser Vorgang wird solange wiederholt, wie die Bedingung wahr ist. Sobald die Bedingung falsch ist, wird die Schleife beendet und die Ausführung des Programms fortgesetzt.

Im Gegensatz zur while-Schleife wird der Codeblock in der do-while-Schleife grundsätzlich mindestens einmal ausgeführt, unabhängig von der Bedingung.

Beispiel für die Verwendung der do-while-Schleife

Ein Beispiel für die Verwendung der do-while-Schleife ist die Eingabe einer Zahl durch den Benutzer, die größer als 10 sein muss. Solange die eingegebene Zahl nicht den gewünschten Wert erreicht, wird der Benutzer aufgefordert, eine neue Zahl einzugeben.

cpp
int num;
do
{
cout << "Bitte gib eine Zahl größer als 10 ein: ";
cin >> num;
}
while (num <= 10);


Der Codeblock innerhalb der do-while-Schleife wird mindestens einmal ausgeführt, unabhängig davon, ob die Bedingung von Anfang an erfüllt ist oder nicht.

Vorteile der do-while-Schleife

Die do-while-Schleife ist besonders nützlich, wenn ein Codeblock mindestens einmal ausgeführt werden muss, bevor die Bedingung überprüft wird. Dadurch kann sichergestellt werden, dass bestimmte Aktionen immer ausgeführt werden, bevor die Schleife beendet wird.

Fazit

Die do-while-Schleife ist eine wertvolle Ergänzung der Schleifen in C++. Sie ermöglicht die Ausführung eines Codeblocks mindestens einmal, unabhängig von der übergeordneten Bedingung. Dadurch können spezifische Aufgaben effizient umgesetzt werden, bei denen eine initiale Ausführung vor der Bedingungsüberprüfung erforderlich ist.

Die For-Schleife

Die for-Schleife ist eine häufig verwendete Schleifenart in C++, die es ermöglicht, einen Codeblock eine bestimmte Anzahl von Malen zu wiederholen. Im Gegensatz zur while-Schleife bietet die for-Schleife eine kompakte Möglichkeit, eine Schleife zu initialisieren, eine Bedingung zu prüfen und eine Iteration durchzuführen.

Syntax der for-Schleife

Die for-Schleife hat eine spezifische Syntax, die aus drei Hauptteilen besteht:

cpp
for (Initialisierung; Bedingung; Iteration)
{
// Codeblock, der wiederholt ausgeführt wird
}


1. Initialisierung: In diesem Teil wird eine Variable initialisiert, die für die Durchführung der Schleife verwendet wird. Oft wird hier ein Zähler initialisiert.

2. Bedingung: Hier wird eine Bedingung angegeben, die bei jeder Iteration überprüft wird. Solange diese Bedingung wahr ist, wird der Codeblock weiterhin ausgeführt. Wenn die Bedingung falsch wird, wird die Schleife beendet.

3. Iteration: In diesem Teil wird festgelegt, wie sich die Schleifenvariable bei jeder Iteration ändert. Oft wird hier die Schleifenvariable inkrementiert oder dekrementiert.

Funktionsweise der for-Schleife

Die for-Schleife führt den Codeblock in ihrem Inneren aus, solange die Bedingung wahr ist. Bei jedem Durchlauf wird zunächst die Initialisierung durchgeführt. Danach wird die Bedingung überprüft. Falls die Bedingung wahr ist, wird der Codeblock ausgeführt. Nach der Ausführung des Codeblocks findet die Iteration statt. Die Schleifenvariable wird entsprechend inkrementiert oder dekrementiert und dann wird die Bedingung erneut überprüft. Dieser Prozess wird so lange wiederholt, bis die Bedingung falsch ist, und die Schleife wird beendet.

Beispiel für die Verwendung der for-Schleife

Ein häufiges Beispiel für die Verwendung der for-Schleife ist das Ausgeben von Zahlen von 1 bis 5:

cpp
for (int i = 1; i <= 5; i++)
{
cout << i << " ";
}


Das obige Beispiel initialisiert den Zähler `i` mit 1, prüft, ob `i` kleiner oder gleich 5 ist, und führt den Codeblock aus. Nach jeder Iteration wird `i` inkrementiert, und die Schleife wird fortgesetzt, solange die Bedingung wahr ist. Das Ergebnis ist die Ausgabe der Zahlen 1, 2, 3, 4 und 5.

Vorteile der for-Schleife

Die for-Schleife ist ideal, wenn du die Anzahl der Durchläufe im Voraus kennst oder wenn du eine Präzisionssteuerung über die Schleifenvariable benötigst. Sie ermöglicht eine kompakte und übersichtliche Schreibweise, um Schleifen zu implementieren.

Fazit

Die for-Schleife ist eine leistungsstarke Schleifenart in C++, die es ermöglicht, einen Codeblock eine bestimmte Anzahl von Malen zu wiederholen. Durch ihre kompakte Syntax und die klare Struktur ist die for-Schleife eine sehr beliebte Option in vielen Programmierszenarien.

Die break-Anweisung

Die break-Anweisung ist eine wichtige Funktion in C++, die es ermöglicht, eine Schleife vorzeitig zu beenden, auch wenn die Bedingung noch nicht erfüllt ist. Mit der break-Anweisung kannst du die Ausführung einer Schleife abbrechen und direkt zum Code außerhalb der Schleife springen.

Funktionsweise der break-Anweisung

Wenn die break-Anweisung innerhalb einer Schleife erreicht wird, wird die Schleife sofort beendet, unabhängig von der Bedingung, die normalerweise die Schleife kontrolliert. Der Programmfluss wird direkt aus der Schleife heraus fortgesetzt. Die break-Anweisung ist besonders nützlich, wenn du einen bestimmten Zustand erreichst oder eine Bedingung erfüllst und die Schleife nicht weiter ausführen möchtest.

Verwendung der break-Anweisung

Die break-Anweisung kann in verschiedenen Schleifenarten wie der while-Schleife, do-while-Schleife und for-Schleife verwendet werden. Hier ist ein Beispiel, wie die break-Anweisung in einer while-Schleife angewendet werden kann:

cpp
int i = 0;
while (i < 10)
{
cout << i << " ";
i++;
if (i == 5)
{
break;
}
}


In diesem Beispiel wird die Schleife solange ausgeführt, bis `i` den Wert von 5 erreicht. Sobald dieser Zustand erreicht ist, wird die break-Anweisung verwendet, um die Schleife zu beenden. Ausgabe: 0 1 2 3 4.

Vorteile der break-Anweisung

Die break-Anweisung ermöglicht eine verbesserte Kontrolle über den Schleifenfluss, da bestimmte Bedingungen erfüllt werden können, um eine Schleife vorzeitig zu beenden. Dies kann nützlich sein, um eine Endlosschleife zu verhindern oder einen bestimmten Codeabschnitt nur unter bestimmten Bedingungen auszuführen.

Fazit

Die break-Anweisung ist ein leistungsstarkes Werkzeug in C++, um Schleifen vorzeitig zu beenden. Sie bietet die Flexibilität, die Ausführung einer Schleife basierend auf bestimmten Zuständen oder Bedingungen zu steuern. Mit der break-Anweisung kannst du deine Schleifen effizienter und genauer steuern.

Die continue-Anweisung

Die continue-Anweisung ist eine Funktion in C++, die es ermöglicht, den aktuellen Schleifendurchlauf vorzeitig zu beenden und mit dem nächsten Durchlauf fortzufahren. Mit der continue-Anweisung kannst du bestimmte Teile deines Codes überspringen, ohne die Schleife zu verlassen.

Funktionsweise der continue-Anweisung

Wenn die continue-Anweisung innerhalb einer Schleife erreicht wird, werden alle nachfolgenden Anweisungen innerhalb des aktuellen Durchlaufs übersprungen. Der Programmfluss springt zurück an den Anfang der Schleife, und mit dem nächsten Schleifendurchlauf wird fortgefahren. Du kannst die continue-Anweisung verwenden, um bestimmte Bedingungen zu bestimmen und nur bestimmte Teile einer Schleife auszuführen.

Verwendung der continue-Anweisung

Die continue-Anweisung kann in verschiedenen Schleifenarten wie der while-Schleife, der do-while-Schleife und der for-Schleife verwendet werden. Hier ist ein Beispiel, wie die continue-Anweisung in einer for-Schleife angewendet werden kann:

cpp
for (int i = 1; i <= 5; i++)
{
if (i == 3)
{
continue;
}
cout << i << " ";
}


In diesem Beispiel wird die Schleife ausgeführt, um Zahlen von 1 bis 5 auszugeben. Wenn `i` den Wert 3 erreicht, wird die continue-Anweisung verwendet, um den restlichen Codeblock innerhalb des aktuellen Durchlaufs zu überspringen. Die Ausgabe lautet: 1 2 4 5.

Vorteile der continue-Anweisung

Die continue-Anweisung ermöglicht eine verbesserte Kontrolle über den Schleifenfluss, indem bestimmte Teile des Codes übersprungen werden. Dadurch kannst du komplexere Bedingungen festlegen und genau steuern, welche Teile des Codes in jeder Schleifeniteration ausgeführt werden sollen.

Fazit

Die continue-Anweisung ist ein leistungsstarkes Werkzeug in C++, um Schleifen präzise zu steuern und bestimmte Teile des Codes zu überspringen. Indem du die continue-Anweisung in geeigneten Situationen verwendest, kannst du deine Schleifen effizienter gestalten und die gewünschte Funktionalität erreichen.

Strukturierte Programmierung

Bei der strukturierten Programmierung handelt es sich um eine Herangehensweise an das Schreiben von Code, bei der der Fokus auf der klaren Strukturierung und Organisation des Codes liegt. Durch die Verwendung von Kontrollstrukturen wie Schleifen und bedingten Anweisungen wird der Code lesbarer, leichter verständlich und einfacher zu warten.

Warum strukturierte Programmierung?

Die strukturierte Programmierung ist ein wichtiger Ansatz für die Entwicklung von Software, da sie eine ganze Reihe von Vorteilen bietet:

• Lesbarkeit: Durch die Verwendung von gut definierten Kontrollstrukturen wie Schleifen und bedingten Anweisungen wird der Code lesbarer und leichter verständlich. Dadurch wird es einfacher, Fehler zu erkennen und den Code zu warten.

• Wartbarkeit: Strukturierte Programme sind modular aufgebaut, was bedeutet, dass der Code in kleinere, überschaubare Einheiten unterteilt ist. Dadurch ist es einfacher, Bugs zu finden und Änderungen vorzunehmen, ohne den gesamten Code zu beeinträchtigen.

• Effizienz: Die Verwendung von Schleifen ermöglicht es, Code zu wiederholen, und bedingte Anweisungen ermöglichen es, Code je nach bestimmten Bedingungen auszuführen oder zu überspringen. Dadurch wird der Code effizienter und weniger fehleranfällig.

Grundprinzipien der strukturierten Programmierung

Die strukturierte Programmierung basiert auf einigen grundlegenden Prinzipien, die dabei helfen, den Code besser zu organisieren und zu strukturieren:

• Klar definierte Funktionen: Der Code wird in Funktionen unterteilt, die eine spezifische Aufgabe oder Operation ausführen. Dadurch wird der Code modular und leichter verständlich.

• Kontrollstrukturen: Schleifen wie die while-Schleife, die do-while-Schleife und die for-Schleife ermöglichen es, Code zu wiederholen. Bedingte Anweisungen wie if-else und switch-case ermöglichen es, Code basierend auf bestimmten Bedingungen auszuführen oder zu überspringen.

• Vermeidung von GOTO-Anweisungen: In der strukturierten Programmierung werden GOTO-Anweisungen vermieden, da sie den Code unübersichtlich und schwerer nachzuvollziehen machen können. Stattdessen werden Schleifen und bedingte Anweisungen verwendet, um den Programmfluss zu steuern.

Beispiel für strukturierte Programmierung

Ein Beispiel für die Anwendung der strukturierten Programmierung ist ein Programm, das die Summe aller Zahlen von 1 bis 10 berechnet:

cpp
int sum = 0;
for (int i = 1; i <= 10; i++)
{
sum += i;
}
cout << "Die Summe ist: " << sum;


In diesem Beispiel wird der Code in einer Schleife ausgeführt, um die Zahlen von 1 bis 10 zu summieren. Durch die Verwendung einer Schleife wird der Code effizienter und leichter zu verstehen.

Fazit

Die strukturierte Programmierung ist eine wichtige Methode zur Entwicklung von Software. Durch klare Strukturierung, die Verwendung von Kontrollstrukturen und die Unterteilung des Codes in Funktionen wird der Code lesbarer, wartbarer und effizienter. Die strukturierte Programmierung ist ein grundlegendes Konzept, das in vielen Programmiersprachen, einschließlich C++, angewendet wird, um qualitativ hochwertigen Code zu schreiben.

Beispielprogramm: Zahl erraten

In diesem Abschnitt möchten wir dir ein Beispielprogramm vorstellen, das dir zeigt, wie du Schleifen in C++ verwenden kannst, um ein einfaches Spiel zu erstellen, bei dem du eine Zahl erraten musst.

Das Spiel "Zahl erraten"

Das Spiel "Zahl erraten" ist ein beliebtes Rätsel- und Schleifenübungsprogramm. Es funktioniert folgendermaßen:

1. Das Programm generiert eine zufällige Zahl zwischen 1 und 100, die der Spieler erraten muss.

2. Der Spieler wird dazu aufgefordert, eine Zahl einzugeben.

3. Das Programm überprüft, ob die eingegebene Zahl mit der zufälligen Zahl übereinstimmt.

4. Wenn die eingegebene Zahl korrekt ist, gibt das Programm eine Glückwunschnachricht aus und beendet das Spiel.

5. Wenn die eingegebene Zahl nicht korrekt ist, gibt das Programm entsprechende Hinweise (zum Beispiel "Zu hoch" oder "Zu niedrig") und fordert den Spieler erneut auf, eine Zahl einzugeben.

6. Der Schleifenprozess wird solange fortgesetzt, bis der Spieler die richtige Zahl erraten hat.

Implementierung des Beispielprogramms

cpp
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
int main()
{
// Zufällige Zahl generieren
srand(time(0));
int zufallszahl = rand() % 100 + 1;
// Spielstart
cout << "Willkommen beim Spiel 'Zahl erraten'!" << endl;
cout << "Versuche, die zufällige Zahl zwischen 1 und 100 zu erraten." << endl;
int eingabe;
bool erraten = false;
// Schleife für das Spiel
while (!erraten)
{
cout << "Gib eine Zahl ein: ";
cin >> eingabe;
// Überprüfung der eingegebenen Zahl
if (eingabe == zufallszahl)
{
cout << "Glückwunsch! Du hast die Zahl erraten." << endl;
erraten = true;
}
else if (eingabe > zufallszahl)
{
cout << "Zu hoch! Versuche es erneut." << endl;
}
else
{
cout << "Zu niedrig! Versuche es erneut." << endl;
}
}
return 0;
}


Funktionsweise des Beispielprogramms

Das Beispielprogramm beginnt mit der Deklaration und Initialisierung einer Variablen `zufallszahl`, die eine zufällig generierte Zahl zwischen 1 und 100 enthält. Mithilfe der Funktion `rand()` und der Funktion `srand(time(0))` wird ein zufälliger Wert basierend auf der aktuellen Uhrzeit erzeugt.

Nach der Spielstartnachricht wird der Benutzer aufgefordert, eine Zahl einzugeben. Die eingegebene Zahl wird mit der zufälligen Zahl verglichen. Wenn die eingegebene Zahl mit der zufälligen Zahl übereinstimmt, wird dem Benutzer eine Glückwunschnachricht angezeigt und das Spiel endet. Andernfalls wird je nachdem, ob die eingegebene Zahl zu hoch oder zu niedrig ist, eine entsprechende Nachricht ausgegeben. Der Spieler bekommt dann die Möglichkeit, eine neue Zahl einzugeben und der Schleifenprozess beginnt von vorne.

Fazit

Das Beispielprogramm "Zahl erraten" zeigt dir, wie du Schleifen in C++ verwenden kannst, um ein einfaches Spiel zu implementieren. Du kannst dieses Programm als Grundlage verwenden und es nach Belieben erweitern oder anpassen. Mit Schleifen kannst du wiederholte Aufgaben in deinem Code einfach und effizient umsetzen. Viel Spaß beim Programmieren!