Kontrollflussstrukturen in C++

Einführung

In diesem Lab lernen Sie, wie Sie verschiedene Kontrollflussstrukturen in C++ implementieren, einschließlich einfacher und mehrzweigiger if-else-Anweisungen, switch-Anweisungen, zählergesteuerter for-Schleifen, eingangsgesteuerter while-Schleifen, ausgangsgesteuerter do-while-Schleifen und geschachtelter Schleifen. Sie werden auch die Verwendung der break- und continue-Anweisungen zur Steuerung der Schleifenausführung untersuchen. Diese grundlegenden Programmierkonstrukte sind für die Entwicklung komplexerer und dynamischerer Anwendungen in C++ unerlässlich.

Das Lab behandelt eine Reihe von Themen, von der Schreibung bedingter Anweisungen bis hin zur Erstellung von Schleifen mit unterschiedlicher Ausführungslogik. Am Ende dieses Labs werden Sie einen soliden Überblick darüber haben, wie Sie diese Kontrollflussstrukturen nutzen können, um Ihre C++-Programme flexibler zu gestalten und an verschiedene Szenarien anzupassen.

Schreiben von einfachen und mehrzweigigen if-else-Anweisungen

In diesem Schritt lernen Sie, wie Sie einfache und mehrzweigige if-else-Anweisungen in C++ schreiben. Bedingte Anweisungen ermöglichen es Ihrem Programm, Entscheidungen zu treffen und verschiedene Codeblöcke basierend auf bestimmten Bedingungen auszuführen.

Zunächst navigieren Sie in das Projektverzeichnis und erstellen eine neue C++-Datei für dieses Lab:

cd ~/project
touch conditional_statements.cpp

Öffnen Sie die Datei conditional_statements.cpp in der WebIDE und fügen Sie den folgenden Code hinzu, um einfache und mehrzweigige if-else-Anweisungen zu untersuchen:

#include <iostream>

int main() {
    // Single if statement
    int number = 10;
    if (number > 5) {
        std::cout << "Number is greater than 5" << std::endl;
    }

    // if-else statement
    int age = 20;
    if (age >= 18) {
        std::cout << "You are an adult" << std::endl;
    } else {
        std::cout << "You are a minor" << std::endl;
    }

    // Multi-branch if-else statement
    int score = 75;
    if (score >= 90) {
        std::cout << "Grade: A" << std::endl;
    } else if (score >= 80) {
        std::cout << "Grade: B" << std::endl;
    } else if (score >= 70) {
        std::cout << "Grade: C" << std::endl;
    } else if (score >= 60) {
        std::cout << "Grade: D" << std::endl;
    } else {
        std::cout << "Grade: F" << std::endl;
    }

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ conditional_statements.cpp -o conditional_statements
./conditional_statements

Beispielausgabe:

Number is greater than 5
You are an adult
Grade: C

Lassen Sie uns die verschiedenen Arten von if-else-Anweisungen analysieren:

1. Einfache if-Anweisung:

   • Führt einen Codeblock aus, wenn die Bedingung wahr ist
   • Es gibt keine alternative Aktion, wenn die Bedingung falsch ist

2. if-else-Anweisung:

   • Bietet zwei Ausführungswege
   • Führt einen Block aus, wenn die Bedingung wahr ist
   • Führt einen anderen Block aus, wenn die Bedingung falsch ist

3. Mehrzweigige if-else-Anweisung:

   • Ermöglicht die Prüfung mehrerer Bedingungen
   • Nutzt else if, um weitere Bedingungen hinzuzufügen
   • Der else-Block dient als Standardfall

Wichtige Punkte zu if-else-Anweisungen:

• Bedingungen werden von oben nach unten ausgewertet
• Nur ein Codeblock wird ausgeführt
• Verwenden Sie geschweifte Klammern { }, um Codeblöcke zu definieren
• Vergleichsoperatoren wie >, >=, <, <=, ==, != werden in Bedingungen verwendet

Erstellen einer switch-Anweisung mit mehreren case-Bezeichnungen

In diesem Schritt lernen Sie, wie Sie die switch-Anweisung in C++ verwenden, um mehrere Bedingungen basierend auf einer einzigen Variablen zu verarbeiten. Die switch-Anweisung bietet eine Alternative zu mehreren if-else-Anweisungen, wenn Sie eine Variable mit verschiedenen konstanten Werten vergleichen.

Zunächst navigieren Sie in das Projektverzeichnis und erstellen eine neue C++-Datei:

cd ~/project
touch switch_statement.cpp

Öffnen Sie die Datei switch_statement.cpp in der WebIDE und fügen Sie den folgenden Code hinzu, um switch-Anweisungen zu untersuchen:

#include <iostream>

int main() {
    // Basic switch statement with multiple case labels
    int dayNumber = 3;

    switch (dayNumber) {
        case 1:
            std::cout << "Monday" << std::endl;
            break;
        case 2:
            std::cout << "Tuesday" << std::endl;
            break;
        case 3:
            std::cout << "Wednesday" << std::endl;
            break;
        case 4:
            std::cout << "Thursday" << std::endl;
            break;
        case 5:
            std::cout << "Friday" << std::endl;
            break;
        case 6:
            std::cout << "Saturday" << std::endl;
            break;
        case 7:
            std::cout << "Sunday" << std::endl;
            break;
        default:
            std::cout << "Invalid day number" << std::endl;
    }

    // Switch statement with multiple cases sharing the same code block
    char grade = 'B';

    switch (grade) {
        case 'A':
        case 'B':
            std::cout << "Excellent performance!" << std::endl;
            break;
        case 'C':
        case 'D':
            std::cout << "Good performance" << std::endl;
            break;
        case 'F':
            std::cout << "Need improvement" << std::endl;
            break;
        default:
            std::cout << "Invalid grade" << std::endl;
    }

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ switch_statement.cpp -o switch_statement
./switch_statement

Beispielausgabe:

Wednesday
Excellent performance!

Wichtige Punkte zu switch-Anweisungen:

1. Wird verwendet, um einen von vielen Codeblöcken auszuwählen und auszuführen
2. Funktioniert mit ganzzahligen Typen (int, char, enum)
3. Jeder case repräsentiert einen möglichen Wert
4. Die break-Anweisung verhindert, dass die Ausführung in den nächsten case übergeht
5. Der default-Fall behandelt Werte, die von anderen case-Werten nicht übereinstimmen
6. Mehrere case-Werte können den gleichen Codeblock teilen

Wichtige Regeln für switch-Anweisungen:

• Jeder case muss mit einer break- oder return-Anweisung enden
• case-Werte müssen konstante Ausdrücke sein
• Nur ein Codeblock wird ausgeführt
• Der default-Fall ist optional, aber empfohlen

Initialisieren von zählergesteuerten for-Schleifen

In diesem Schritt lernen Sie, wie Sie zählergesteuerte for-Schleifen in C++ verwenden. for-Schleifen sind unerlässlich, um einen Codeblock eine bestimmte Anzahl von Malen auszuführen. Sie eignen sich daher perfekt für Aufgaben, die eine Wiederholung mit einer bekannten Anzahl von Iterationen erfordern.

Zunächst navigieren Sie in das Projektverzeichnis und erstellen eine neue C++-Datei:

cd ~/project
touch for_loops.cpp

Öffnen Sie die Datei for_loops.cpp in der WebIDE und fügen Sie den folgenden Code hinzu, um verschiedene Möglichkeiten der Initialisierung und Verwendung von for-Schleifen zu untersuchen:

#include <iostream>

int main() {
    // Basic counter-controlled for loop
    std::cout << "Counting from 1 to 5:" << std::endl;
    for (int i = 1; i <= 5; i++) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    // For loop with multiple statements in initialization
    std::cout << "Counting even numbers from 0 to 10:" << std::endl;
    for (int j = 0, k = 10; j <= k; j += 2) {
        std::cout << j << " ";
    }
    std::cout << std::endl;

    // For loop with multiplication table
    std::cout << "Multiplication table for 5:" << std::endl;
    for (int m = 1; m <= 10; m++) {
        std::cout << "5 x " << m << " = " << (5 * m) << std::endl;
    }

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ for_loops.cpp -o for_loops
./for_loops

Beispielausgabe:

Counting from 1 to 5:
1 2 3 4 5
Counting even numbers from 0 to 10:
0 2 4 6 8 10
Multiplication table for 5:
5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50

Wichtige Bestandteile einer for-Schleife:

1. Initialisierung: int i = 1 - Setzt den Anfangswert des Zählers
2. Bedingung: i <= 5 - Definiert, wann die Schleife fortgesetzt werden soll
3. Inkrement/Dekrement: i++ - Ändert den Zähler nach jeder Iteration

Wichtige Eigenschaften von for-Schleifen:

• Ideal für eine bekannte Anzahl von Iterationen
• Kann mehrere Initialisierungsanweisungen haben
• Kann mehrere Variablen in jeder Iteration ändern
• Flexibel bei der Steuerung der Schleifenausführung

Erstellen von while-Schleifen mit eingangsgesteuerter Logik

In diesem Schritt lernen Sie, wie Sie while-Schleifen in C++ verwenden. Eine while-Schleife ist eine eingangsgesteuerte Schleife, die einen Codeblock wiederholt ausführt, solange eine bestimmte Bedingung wahr bleibt. Die Bedingung wird vor jeder Iteration überprüft, was bedeutet, dass die Schleife gar nicht ausgeführt wird, wenn die Anfangsbedingung falsch ist.

Zunächst navigieren Sie in das Projektverzeichnis und erstellen eine neue C++-Datei:

cd ~/project
touch while_loops.cpp

Öffnen Sie die Datei while_loops.cpp in der WebIDE und fügen Sie den folgenden Code hinzu, um verschiedene Möglichkeiten der Verwendung von while-Schleifen zu untersuchen:

#include <iostream>

int main() {
    // Basic while loop counting
    std::cout << "Counting from 1 to 5:" << std::endl;
    int count = 1;
    while (count <= 5) {
        std::cout << count << " ";
        count++;
    }
    std::cout << std::endl;

    // While loop with user input validation
    int userNumber;
    std::cout << "Enter a number between 1 and 10: ";
    std::cin >> userNumber;

    while (userNumber < 1 || userNumber > 10) {
        std::cout << "Invalid input. Enter a number between 1 and 10: ";
        std::cin >> userNumber;
    }
    std::cout << "You entered a valid number: " << userNumber << std::endl;

    // While loop calculating factorial
    int number = 5;
    int factorial = 1;
    int i = 1;

    std::cout << "Calculating factorial of " << number << ":" << std::endl;
    while (i <= number) {
        factorial *= i;
        i++;
    }
    std::cout << number << "! = " << factorial << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ while_loops.cpp -o while_loops
./while_loops

Beispielausgabe:

Counting from 1 to 5:
1 2 3 4 5
Enter a number between 1 and 10: 15
Invalid input. Enter a number between 1 and 10: 7
You entered a valid number: 7
Calculating factorial of 5:
5! = 120

Wichtige Eigenschaften von while-Schleifen:

1. Die Bedingung wird vor jeder Iteration überprüft.
2. Die Schleife wird möglicherweise nicht ausgeführt, wenn die Anfangsbedingung falsch ist.
3. Erfordert die manuelle Inkrementierung/Aktualisierung der Schleifenvariablen.
4. Nützlich für Situationen, in denen die Anzahl der Iterationen im Voraus nicht bekannt ist.

Wichtige Bestandteile einer while-Schleife:

• Initialisierung der Schleifenvariablen vor der Schleife
• Bedingung, die die Schleifenausführung steuert
• Aktualisierung der Schleifenvariablen innerhalb des Schleifenkörpers

Implementieren von do-while-Schleifen für ausgangsgesteuerte Logik

In diesem Schritt lernen Sie über do-while-Schleifen in C++. Im Gegensatz zu while-Schleifen sind do-while-Schleifen ausgangsgesteuert, was bedeutet, dass die Bedingung nach der Ausführung des Schleifenkörpers überprüft wird. Dies stellt sicher, dass der Schleifenkörper mindestens einmal ausgeführt wird, unabhängig von der Anfangsbedingung.

Zunächst navigieren Sie in das Projektverzeichnis und erstellen eine neue C++-Datei:

cd ~/project
touch do_while_loops.cpp

Öffnen Sie die Datei do_while_loops.cpp in der WebIDE und fügen Sie den folgenden Code hinzu, um verschiedene Möglichkeiten der Verwendung von do-while-Schleifen zu untersuchen:

#include <iostream>
#include <cstdlib>
#include <ctime>

int main() {
    // Basic do-while loop for user input validation
    int userNumber;
    do {
        std::cout << "Enter a number between 1 and 10: ";
        std::cin >> userNumber;
    } while (userNumber < 1 || userNumber > 10);
    std::cout << "You entered a valid number: " << userNumber << std::endl;

    // Simulating a dice rolling game
    srand(time(0));  // Seed for random number generation
    int attempts = 0;
    int targetNumber = 6;
    int diceRoll;

    std::cout << "Dice Rolling Game:" << std::endl;
    do {
        diceRoll = rand() % 6 + 1;  // Generate random number between 1 and 6
        attempts++;
        std::cout << "Roll " << attempts << ": You rolled " << diceRoll << std::endl;
    } while (diceRoll!= targetNumber);

    std::cout << "Congratulations! You rolled the target number "
              << targetNumber << " in " << attempts << " attempts." << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ do_while_loops.cpp -o do_while_loops
./do_while_loops

Beispielausgabe:

Enter a number between 1 and 10: 15
Enter a number between 1 and 10: 7
You entered a valid number: 7
Dice Rolling Game:
Roll 1: You rolled 1
Roll 2: You rolled 5
Roll 3: You rolled 2
Roll 4: You rolled 5
Roll 5: You rolled 5
Roll 6: You rolled 3
Roll 7: You rolled 4
Roll 8: You rolled 2
Roll 9: You rolled 2
Roll 10: You rolled 2
Roll 11: You rolled 2
Roll 12: You rolled 2
Roll 13: You rolled 1
Roll 14: You rolled 1
Roll 15: You rolled 6
Congratulations! You rolled the target number 6 in 15 attempts.

Wichtige Eigenschaften von do-while-Schleifen:

1. Die Bedingung wird nach der Ausführung des Schleifenkörpers überprüft.
2. Garantiert mindestens eine Ausführung der Schleife.
3. Nützlich für Eingabevalidierung und Spiele.
4. Die Syntax unterscheidet sich von der while-Schleife dadurch, dass die Bedingung am Ende überprüft wird.

Wichtige Bestandteile einer do-while-Schleife:

• Das Schlüsselwort do startet den Schleifenkörper.
• Der Schleifenkörper wird immer mindestens einmal ausgeführt.
• Die while-Bedingung wird nach jeder Iteration ausgewertet.
• Ein Semikolon ; ist nach der while-Bedingung erforderlich.

Verwenden von break zum vorzeitigen Verlassen von Schleifen

In diesem Schritt lernen Sie, wie Sie die break-Anweisung in C++ verwenden, um Schleifen vorzeitig zu verlassen. Die break-Anweisung ermöglicht es Ihnen, eine Schleife sofort zu beenden und die Steuerung an die erste Anweisung nach der Schleife zu übergeben.

Zunächst navigieren Sie in das Projektverzeichnis und erstellen eine neue C++-Datei:

cd ~/project
touch break_statement.cpp

Öffnen Sie die Datei break_statement.cpp in der WebIDE und fügen Sie den folgenden Code hinzu, um verschiedene Möglichkeiten der Verwendung der break-Anweisung zu untersuchen:

#include <iostream>
#include <cstdlib>
#include <ctime>

int main() {
    // Breaking out of a for loop when a condition is met
    std::cout << "Finding the first even number:" << std::endl;
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            std::cout << "First even number found: " << i << std::endl;
            break;
        }
    }

    // Simulating a number guessing game
    srand(time(0));  // Seed for random number generation
    int targetNumber = rand() % 10 + 1;  // Random number between 1 and 10
    int guess;
    int attempts = 0;

    std::cout << "\nNumber Guessing Game:" << std::endl;
    while (true) {
        std::cout << "Enter your guess (1-10): ";
        std::cin >> guess;
        attempts++;

        if (guess == targetNumber) {
            std::cout << "Congratulations! You guessed the number in "
                      << attempts << " attempts." << std::endl;
            break;
        } else if (guess < targetNumber) {
            std::cout << "Too low. Try again." << std::endl;
        } else {
            std::cout << "Too high. Try again." << std::endl;
        }
    }

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ break_statement.cpp -o break_statement
./break_statement

Beispielausgabe:

Finding the first even number:
First even number found: 2

Number Guessing Game:
Enter your guess (1-10): 5
Too low. Try again.
Enter your guess (1-10): 8
Too high. Try again.
Enter your guess (1-10): 6
Congratulations! You guessed the number in 3 attempts.

Wichtige Eigenschaften der break-Anweisung:

1. Beendet sofort die innerste Schleife.
2. Übergibt die Steuerung an die erste Anweisung nach der Schleife.
3. Kann in for-, while- und do-while-Schleifen verwendet werden.
4. Nützlich für das vorzeitige Beenden von Schleifen basierend auf einer Bedingung.

Wichtige Anwendungen der break-Anweisung:

• Verlassen von Schleifen, wenn eine bestimmte Bedingung erfüllt ist.
• Implementieren von Suchalgorithmen.
• Erstellen von interaktiven Programmen mit Benutzer-Eingaben.
• Vermeiden von unnötigen Iterationen.

Überspringen von Schleifeniterationen mit der continue-Anweisung

In diesem Schritt lernen Sie, wie Sie die continue-Anweisung in C++ verwenden, um die aktuelle Iteration einer Schleife zu überspringen und zur nächsten Iteration zu springen. Die continue-Anweisung ermöglicht es Ihnen, Teile einer Schleife selektiv basierend auf bestimmten Bedingungen zu überspringen.

Zunächst navigieren Sie in das Projektverzeichnis und erstellen eine neue C++-Datei:

cd ~/project
touch continue_statement.cpp

Öffnen Sie die Datei continue_statement.cpp in der WebIDE und fügen Sie den folgenden Code hinzu, um verschiedene Möglichkeiten der Verwendung der continue-Anweisung zu untersuchen:

#include <iostream>

int main() {
    // Skipping even numbers in a loop
    std::cout << "Printing odd numbers between 1 and 10:" << std::endl;
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            continue;  // Skip even numbers
        }
        std::cout << i << " ";
    }
    std::cout << std::endl;

    // Filtering out negative numbers in a sum calculation
    int sum = 0;
    int numbers[] = {5, -3, 10, -7, 8, -2, 15};
    int arraySize = sizeof(numbers) / sizeof(numbers[0]);

    std::cout << "\nCalculating sum of positive numbers:" << std::endl;
    for (int j = 0; j < arraySize; j++) {
        if (numbers[j] < 0) {
            continue;  // Skip negative numbers
        }
        sum += numbers[j];
        std::cout << "Added: " << numbers[j] << ", Current Sum: " << sum << std::endl;
    }
    std::cout << "Final Sum of Positive Numbers: " << sum << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ continue_statement.cpp -o continue_statement
./continue_statement

Beispielausgabe:

Printing odd numbers between 1 and 10:
1 3 5 7 9

Calculating sum of positive numbers:
Added: 5, Current Sum: 5
Added: 10, Current Sum: 15
Added: 8, Current Sum: 23
Added: 15, Current Sum: 38
Final Sum of Positive Numbers: 38

Wichtige Eigenschaften der continue-Anweisung:

1. Überspringt den Rest der aktuellen Schleifeniteration.
2. Übergibt die Steuerung an die nächste Iteration der Schleife.
3. Kann in for-, while- und do-while-Schleifen verwendet werden.
4. Nützlich für das Filtern oder die bedingte Verarbeitung.

Wichtige Anwendungen der continue-Anweisung:

• Überspringen bestimmter Iterationen basierend auf Bedingungen.
• Filtern von Daten in Schleifen.
• Vermeiden von unnötigen Berechnungen.
• Vereinfachen der Schleifenlogik.

Erstellen von geschachtelten Schleifen für Matrixoperationen

In diesem Schritt lernen Sie, wie Sie geschachtelte Schleifen verwenden, um Operationen auf 2D-Arrays (Matrizen) in C++ durchzuführen. Geschachtelte Schleifen ermöglichen es Ihnen, durch die Zeilen und Spalten einer Matrix zu iterieren, was komplexe Datenmanipulationen und Berechnungen ermöglicht.

Zunächst navigieren Sie in das Projektverzeichnis und erstellen eine neue C++-Datei:

cd ~/project
touch nested_loops.cpp

Öffnen Sie die Datei nested_loops.cpp in der WebIDE und fügen Sie den folgenden Code hinzu, um Matrixoperationen mit geschachtelten Schleifen zu untersuchen:

#include <iostream>
#include <iomanip>

int main() {
    // Define a 3x3 matrix
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // Print the original matrix
    std::cout << "Original Matrix:" << std::endl;
    for (int row = 0; row < 3; row++) {
        for (int col = 0; col < 3; col++) {
            std::cout << std::setw(4) << matrix[row][col];
        }
        std::cout << std::endl;
    }

    // Calculate row sums
    std::cout << "\nRow Sums:" << std::endl;
    for (int row = 0; row < 3; row++) {
        int rowSum = 0;
        for (int col = 0; col < 3; col++) {
            rowSum += matrix[row][col];
        }
        std::cout << "Row " << row + 1 << " Sum: " << rowSum << std::endl;
    }

    // Create and print a multiplication table
    std::cout << "\nMultiplication Table:" << std::endl;
    for (int i = 1; i <= 5; i++) {
        for (int j = 1; j <= 5; j++) {
            std::cout << std::setw(4) << (i * j);
        }
        std::cout << std::endl;
    }

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ nested_loops.cpp -o nested_loops
./nested_loops

Beispielausgabe:

Original Matrix:
   1   2   3
   4   5   6
   7   8   9

Row Sums:
Row 1 Sum: 6
Row 2 Sum: 15
Row 3 Sum: 24

Multiplication Table:
   1   2   3   4   5
   2   4   6   8  10
   3   6   9  12  15
   4   8  12  16  20
   5  10  15  20  25

Wichtige Eigenschaften von geschachtelten Schleifen:

1. Eine innere Schleife führt alle ihre Iterationen für jede Iteration der äußeren Schleife aus.
2. Nützlich für die Arbeit mit mehrdimensionalen Arrays.
3. Kann verwendet werden, um komplexe Muster zu erstellen und Matrixoperationen durchzuführen.
4. Typischerweise mit 2D-Arrays (Matrizen) und mehrdimensionalen Datenstrukturen verwendet.

Wichtige Konzepte von geschachtelten Schleifen:

• Die äußere Schleife steuert die Anzahl der Ausführungen der inneren Schleife.
• Jede Schleife hat ihre eigene Zählervariable.
• Nützlich für zeilen- und spaltenbasierte Operationen.
• Kann verwendet werden, um Muster zu generieren, Berechnungen durchzuführen und Daten zu manipulieren.

Vermeidung von Endlosschleifen

In diesem Schritt lernen Sie, wie Sie in C++ Endlosschleifen vermeiden können, indem Sie geeignete Schleifensteuerungsmechanismen implementieren. Eine Endlosschleife tritt auf, wenn die Bedingung einer Schleife niemals falsch wird, was dazu führt, dass das Programm unendlich lange läuft.

Zunächst navigieren Sie in das Projektverzeichnis und erstellen eine neue C++-Datei:

cd ~/project
touch infinite_loop_prevention.cpp

Öffnen Sie die Datei infinite_loop_prevention.cpp in der WebIDE und fügen Sie den folgenden Code hinzu, um verschiedene Strategien zur Vermeidung von Endlosschleifen zu untersuchen:

#include <iostream>
#include <cstdlib>
#include <ctime>

int main() {
    // Example 1: Preventing infinite loop with a maximum iteration limit
    std::cout << "Example 1: Iteration Limit Prevention" << std::endl;
    int counter = 0;
    const int MAX_ITERATIONS = 5;

    while (true) {
        std::cout << "Iteration: " << counter + 1 << std::endl;
        counter++;

        if (counter >= MAX_ITERATIONS) {
            std::cout << "Maximum iterations reached. Breaking the loop." << std::endl;
            break;
        }
    }

    // Example 2: User-controlled loop with input validation
    std::cout << "\nExample 2: User-Controlled Loop" << std::endl;
    char continueChoice;
    int attempts = 0;
    const int MAX_ATTEMPTS = 3;

    do {
        std::cout << "Enter a number (1-10): ";
        int userNumber;
        std::cin >> userNumber;

        if (userNumber >= 1 && userNumber <= 10) {
            std::cout << "Valid number entered: " << userNumber << std::endl;
            break;
        }

        attempts++;
        std::cout << "Invalid input. Attempts left: " << MAX_ATTEMPTS - attempts << std::endl;

        if (attempts >= MAX_ATTEMPTS) {
            std::cout << "Maximum attempts reached. Exiting." << std::endl;
            break;
        }

        std::cout << "Do you want to try again? (y/n): ";
        std::cin >> continueChoice;
    } while (continueChoice == 'y' || continueChoice == 'Y');

    // Example 3: Random number game with controlled iterations
    std::cout << "\nExample 3: Random Number Game" << std::endl;
    srand(time(0));  // Seed for random number generation
    int targetNumber = rand() % 10 + 1;
    int guess;
    int gameAttempts = 0;
    const int MAX_GAME_ATTEMPTS = 4;

    std::cout << "Guess the number between 1 and 10" << std::endl;
    while (gameAttempts < MAX_GAME_ATTEMPTS) {
        std::cout << "Attempt " << gameAttempts + 1 << ": Enter your guess: ";
        std::cin >> guess;

        if (guess == targetNumber) {
            std::cout << "Congratulations! You guessed the number." << std::endl;
            break;
        }

        gameAttempts++;

        if (gameAttempts >= MAX_GAME_ATTEMPTS) {
            std::cout << "Sorry, you've run out of attempts. The number was "
                      << targetNumber << std::endl;
            break;
        }
    }

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ infinite_loop_prevention.cpp -o infinite_loop_prevention
./infinite_loop_prevention

Beispielausgabe:

Example 1: Iteration Limit Prevention
Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4
Iteration: 5
Maximum iterations reached. Breaking the loop.

Example 2: User-Controlled Loop
Enter a number (1-10): 1
Valid number entered: 1

Example 3: Random Number Game
Guess the number between 1 and 10
Attempt 1: Enter your guess: 2
Attempt 2: Enter your guess: 3
Attempt 3: Enter your guess: 4
Attempt 4: Enter your guess: 5
Sorry, you've run out of attempts. The number was 8

Wichtige Strategien zur Vermeidung von Endlosschleifen:

1. Setzen Sie eine maximale Anzahl von Iterationen.
2. Verwenden Sie die break-Anweisung, um Schleifen zu verlassen.
3. Implementieren Sie Eingabevalidierung.
4. Fügen Sie bedingte Prüfungen hinzu, um die Schleifenausführung zu steuern.
5. Bieten Sie Benutzersteuerungsmechanismen an.

Wichtige Techniken zur Vermeidung von Endlosschleifen:

• Stellen Sie immer sicher, dass die Schleifenbedingung falsch werden kann.
• Verwenden Sie Zählervariablen, um die Anzahl der Iterationen zu begrenzen.
• Implementieren Sie Abbruchbedingungen innerhalb der Schleife.
• Validieren Sie die Benutzereingabe.
• Verwenden Sie break, um Schleifen bei Bedarf zu verlassen.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie verschiedene Kontrollflussstrukturen in C++ implementieren können, darunter einfache und mehrzweigige if-else-Anweisungen, switch-Anweisungen, zählergesteuerte for-Schleifen, eingangsgesteuerte while-Schleifen, ausgangsgesteuerte do-while-Schleifen und geschachtelte Schleifen. Sie haben die Verwendung der break- und continue-Anweisungen zur Steuerung der Schleifenausführung untersucht und Techniken zur Behandlung von Endlosschleifen gelernt. Diese Kontrollflussstrukturen sind grundlegend für die C++-Programmierung und ermöglichen es Ihnen, komplexere und dynamischere Programme zu schreiben, die Entscheidungen treffen und verschiedene Codepfade basierend auf bestimmten Bedingungen ausführen können.

Das Lab hat die praktische Anwendung dieser Kontrollflussstrukturen durch praktische Codierungsübungen abgedeckt, was Ihnen ermöglicht hat, ein tieferes Verständnis ihrer Verwendung zu entwickeln und die Fähigkeit zu erwerben, sie effektiv in Ihren eigenen C++-Projekten anzuwenden.