Bedingte Schleifen in C

Einführung

In diesem Lab werden Sie lernen, wie Sie bedingte Schleifen in der C-Programmierung implementieren. Sie beginnen damit, die Grundlagen von while-Schleifen zu verstehen und erkunden dann die Verwendung der Anweisungen break und continue zur Steuerung der Schleifenausführung. Darüber hinaus werden Sie lernen, wie Sie Array-Elemente mit bedingten Anweisungen filtern und die Effizienz von Schleifen mit verschiedenen Anweisungen optimieren. Am Ende dieses Labs werden Sie ein solides Verständnis von bedingten Schleifen und ihrer praktischen Anwendung in der C-Programmierung haben.

Skills Graph

while-Schleifen verstehen

In diesem Schritt lernen Sie die Grundlagen von while-Schleifen in der C-Programmierung. While-Schleifen sind leistungsstarke Kontrollstrukturen, die es Ihnen ermöglichen, einen Codeblock so lange wiederholt auszuführen, wie eine bestimmte Bedingung wahr bleibt.

Erstellen wir ein einfaches C-Programm, um die Grundsyntax einer while-Schleife zu demonstrieren. Öffnen Sie den VSCode-Editor und erstellen Sie eine neue Datei namens while_loop_example.c im Verzeichnis ~/project.

cd ~/project
touch while_loop_example.c

#include <stdio.h>

int main() {
    int count = 1;

    while (count <= 5) {
        printf("Current count: %d\n", count);
        count++;
    }

    return 0;
}

Lassen Sie uns den Code analysieren:

• int count = 1; initialisiert eine Zählervariable.
• while (count <= 5) erstellt eine Schleife, die so lange fortgesetzt wird, wie count kleiner oder gleich 5 ist.
• printf() zeigt den aktuellen Wert von count an.
• count++ erhöht den Zähler in jeder Iteration.

Kompilieren und führen Sie das Programm aus:

gcc while_loop_example.c -o while_loop_example
./while_loop_example

Beispielausgabe:

Current count: 1
Current count: 2
Current count: 3
Current count: 4
Current count: 5

Hier ist ein weiteres Beispiel, das eine while-Schleife mit Benutzereingabe demonstriert:

#include <stdio.h>

int main() {
    int number;

    printf("Enter numbers (enter 0 to stop):\n");

    number = 1;  // Initialize to non-zero value
    while (number!= 0) {
        printf("Enter a number: ");
        scanf("%d", &number);

        if (number!= 0) {
            printf("You entered: %d\n", number);
        }
    }

    printf("Loop ended. Goodbye!\n");

    return 0;
}

Dieses Beispiel zeigt, wie while-Schleifen für interaktive Eingaben verwendet werden können, die so lange fortgesetzt werden, bis eine bestimmte Bedingung (Eingabe von 0) erfüllt ist.

Die break-Anweisung in while-Schleifen anwenden

In diesem Schritt lernen Sie die break-Anweisung in der C-Programmierung kennen, die es Ihnen ermöglicht, eine Schleife vorzeitig zu beenden, wenn eine bestimmte Bedingung erfüllt ist. Die break-Anweisung bietet eine Möglichkeit, die aktuelle Schleife sofort zu beenden und die Ausführung mit der nächsten Anweisung nach der Schleife fortzusetzen.

Erstellen wir eine neue Datei namens break_loop_example.c im Verzeichnis ~/project, um die Verwendung von break zu demonstrieren:

cd ~/project
touch break_loop_example.c

#include <stdio.h>

int main() {
    int number;

    printf("Enter numbers to find the first multiple of 10:\n");

    while (1) {  // Infinite loop
        printf("Enter a number: ");
        scanf("%d", &number);

        if (number % 10 == 0) {
            printf("Found a multiple of 10: %d\n", number);
            break;  // Exit the loop when a multiple of 10 is found
        }

        printf("Not a multiple of 10. Try again.\n");
    }

    printf("Loop terminated after finding a multiple of 10.\n");

    return 0;
}

Lassen Sie uns den Code analysieren:

• while (1) erstellt eine Endlosschleife, die so lange fortgesetzt wird, bis eine break-Anweisung erreicht wird.
• Wenn der Benutzer eine Zahl eingibt, die durch 10 teilbar ist, beendet die break-Anweisung die Schleife sofort.
• Wenn die Zahl nicht durch 10 teilbar ist, fordert die Schleife weiterhin zur Eingabe auf.

Hier ist ein weiteres Beispiel, das break in einem komplexeren Szenario demonstriert:

#include <stdio.h>

int main() {
    int sum = 0;
    int count = 0;
    int input;

    printf("Enter numbers (enter a negative number to stop):\n");

    while (1) {
        printf("Enter a number: ");
        scanf("%d", &input);

        if (input < 0) {
            break;  // Exit the loop if a negative number is entered
        }

        sum += input;
        count++;
    }

    if (count > 0) {
        printf("Average of entered numbers: %.2f\n", (float)sum / count);
    } else {
        printf("No numbers were entered.\n");
    }

    return 0;
}

Dieses Beispiel zeigt, wie break verwendet werden kann, um:

• Die Eingabeaufforderung zu beenden, wenn eine bestimmte Bedingung erfüllt ist.
• Den Durchschnitt der eingegebenen Zahlen zu berechnen.
• Flexibilität bei der Schleifenbeendigung zu bieten.

Kompilieren und führen Sie die Programme aus, um zu sehen, wie die break-Anweisung funktioniert:

gcc break_loop_example.c -o break_loop_example
./break_loop_example

Die continue-Anweisung in while-Schleifen nutzen

In diesem Schritt lernen Sie die continue-Anweisung in der C-Programmierung kennen, die es Ihnen ermöglicht, die aktuelle Iteration einer Schleife zu überspringen und zur nächsten Iteration zu springen. Die continue-Anweisung bietet eine Möglichkeit, Teile einer Schleife basierend auf bestimmten Bedingungen selektiv auszuführen oder zu überspringen.

Erstellen wir eine neue Datei namens continue_loop_example.c im Verzeichnis ~/project, um die Verwendung von continue zu demonstrieren:

cd ~/project
touch continue_loop_example.c

#include <stdio.h>

int main() {
    int number;
    int sum_even = 0;
    int count_even = 0;

    printf("Enter 10 numbers to calculate the sum and count of even numbers:\n");

    int i = 0;
    while (i < 10) {
        printf("Enter number %d: ", i + 1);
        scanf("%d", &number);

        // Skip odd numbers
        if (number % 2!= 0) {
            printf("Skipping odd number: %d\n", number);
            continue;  // Move to the next iteration
        }

        sum_even += number;
        count_even++;

        i++;
    }

    if (count_even > 0) {
        printf("Sum of even numbers: %d\n", sum_even);
        printf("Count of even numbers: %d\n", count_even);
        printf("Average of even numbers: %.2f\n", (float)sum_even / count_even);
    } else {
        printf("No even numbers were entered.\n");
    }

    return 0;
}

Lassen Sie uns den Code analysieren:

• Das Programm bittet den Benutzer, 10 Zahlen einzugeben.
• if (number % 2!= 0) prüft, ob die Zahl ungerade ist.
• continue überspringt den Rest der aktuellen Iteration für ungerade Zahlen.
• Nur gerade Zahlen werden zur Summe addiert und gezählt.

Hier ist ein weiteres Beispiel, das continue mit komplexeren Bedingungen demonstriert:

#include <stdio.h>

int main() {
    int number;
    int positive_count = 0;
    int negative_count = 0;

    printf("Enter numbers (enter 0 to stop):\n");

    while (1) {
        printf("Enter a number: ");
        scanf("%d", &number);

        // Exit the loop if 0 is entered
        if (number == 0) {
            break;
        }

        // Skip zero
        if (number == 0) {
            continue;
        }

        // Count positive and negative numbers
        if (number > 0) {
            positive_count++;
        } else {
            negative_count++;
        }
    }

    printf("Positive numbers count: %d\n", positive_count);
    printf("Negative numbers count: %d\n", negative_count);

    return 0;
}

Dieses Beispiel zeigt, wie continue verwendet werden kann, um:

• Spezifische Werte zu überspringen.
• Zahlen basierend auf Bedingungen selektiv zu verarbeiten.
• Flexiblere Schleifensteuerung zu ermöglichen.

Kompilieren und führen Sie die Programme aus, um zu sehen, wie die continue-Anweisung funktioniert:

gcc continue_loop_example.c -o continue_loop_example
./continue_loop_example

Array-Elemente mit bedingten Anweisungen filtern

In diesem Schritt lernen Sie, wie Sie Array-Elemente in der C-Programmierung mithilfe von bedingten Anweisungen und Schleifen filtern können. Das Filtern ermöglicht es Ihnen, bestimmte Elemente aus einem Array basierend auf bestimmten Bedingungen auszuwählen.

Erstellen wir eine neue Datei namens array_filtering.c im Verzeichnis ~/project, um das Filtern von Array-Elementen zu demonstrieren:

cd ~/project
touch array_filtering.c

#include <stdio.h>

#define MAX_SIZE 10

int main() {
    int numbers[MAX_SIZE];
    int filtered_even[MAX_SIZE];
    int filtered_count = 0;

    // Input array elements
    printf("Enter %d numbers:\n", MAX_SIZE);
    for (int i = 0; i < MAX_SIZE; i++) {
        printf("Enter number %d: ", i + 1);
        scanf("%d", &numbers[i]);
    }

    // Filter even numbers
    printf("\nFiltered Even Numbers:\n");
    for (int i = 0; i < MAX_SIZE; i++) {
        if (numbers[i] % 2 == 0) {
            filtered_even[filtered_count] = numbers[i];
            filtered_count++;
            printf("%d ", numbers[i]);
        }
    }

    printf("\n\nTotal even numbers: %d\n", filtered_count);

    return 0;
}

Lassen Sie uns den Filterprozess analysieren:

• Wir erstellen zwei Arrays: numbers zum Speichern der Eingabe und filtered_even zum Speichern der gefilterten Elemente.
• Die erste Schleife liest 10 Zahlen vom Benutzer ein.
• Die zweite Schleife verwendet eine bedingte Anweisung, um gerade Zahlen zu filtern.
• if (numbers[i] % 2 == 0) prüft, ob eine Zahl gerade ist.
• Übereinstimmende Elemente werden im filtered_even-Array gespeichert.

Hier ist ein komplexeres Beispiel mit mehreren Filterbedingungen:

#include <stdio.h>

#define MAX_SIZE 10

int main() {
    int numbers[MAX_SIZE];
    int prime_numbers[MAX_SIZE];
    int prime_count = 0;

    // Input array elements
    printf("Enter %d numbers:\n", MAX_SIZE);
    for (int i = 0; i < MAX_SIZE; i++) {
        printf("Enter number %d: ", i + 1);
        scanf("%d", &numbers[i]);
    }

    // Filter prime numbers
    printf("\nFiltered Prime Numbers:\n");
    for (int i = 0; i < MAX_SIZE; i++) {
        // Skip numbers less than 2
        if (numbers[i] < 2) continue;

        int is_prime = 1;
        for (int j = 2; j * j <= numbers[i]; j++) {
            if (numbers[i] % j == 0) {
                is_prime = 0;
                break;
            }
        }

        // Add prime numbers to filtered array
        if (is_prime) {
            prime_numbers[prime_count] = numbers[i];
            prime_count++;
            printf("%d ", numbers[i]);
        }
    }

    printf("\n\nTotal prime numbers: %d\n", prime_count);

    return 0;
}

Dieses Beispiel demonstriert:

• Das Filtern von Primzahlen aus einem Eingabe-Array.
• Verschachtelte Schleifen zur Prüfung auf Primzahl.
• Das Speichern der gefilterten Elemente in einem separaten Array.

Kompilieren und führen Sie die Programme aus:

gcc array_filtering.c -o array_filtering
./array_filtering

Beispiel-Eingabe und -Ausgabe:

Enter 10 numbers:
Enter number 1: 5
Enter number 2: 12
Enter number 3: 7
Enter number 4: 15
...

Filtered Prime Numbers:
5 7

Total prime numbers: 2

Schleifen-Effizienz mit Direktiven optimieren

In diesem Schritt lernen Sie Techniken kennen, um die Effizienz von Schleifen in der C-Programmierung mithilfe verschiedener Direktiven und Strategien zu optimieren. Wir werden verschiedene Ansätze untersuchen, um die Leistung und Lesbarkeit von Schleifen zu verbessern.

Erstellen wir eine Datei namens loop_optimization.c im Verzeichnis ~/project, um Optimierungstechniken zu demonstrieren:

cd ~/project
touch loop_optimization.c

#include <stdio.h>
#include <time.h>

#define ARRAY_SIZE 10000

// Function to calculate sum using traditional loop
int traditional_sum(int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

// Function to calculate sum using optimized loop
int optimized_sum(int arr[], int size) {
    int sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0;

    // Loop unrolling technique
    int i;
    for (i = 0; i + 4 < size; i += 4) {
        sum1 += arr[i];
        sum2 += arr[i + 1];
        sum3 += arr[i + 2];
        sum4 += arr[i + 3];
    }

    // Handle remaining elements
    for (; i < size; i++) {
        sum1 += arr[i];
    }

    return sum1 + sum2 + sum3 + sum4;
}

int main() {
    int arr[ARRAY_SIZE];
    clock_t start, end;
    double cpu_time_used;

    // Initialize array
    for (int i = 0; i < ARRAY_SIZE; i++) {
        arr[i] = i + 1;
    }

    // Traditional sum
    start = clock();
    int traditional_result = traditional_sum(arr, ARRAY_SIZE);
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("Traditional Sum: %d\n", traditional_result);
    printf("Traditional Loop Time: %f seconds\n", cpu_time_used);

    // Optimized sum
    start = clock();
    int optimized_result = optimized_sum(arr, ARRAY_SIZE);
    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("Optimized Sum: %d\n", optimized_result);
    printf("Optimized Loop Time: %f seconds\n", cpu_time_used);

    return 0;
}

Hier ist ein weiteres Beispiel, das mehrere Optimierungstechniken demonstriert:

#include <stdio.h>

#define MAX_SIZE 1000

int main() {
    int numbers[MAX_SIZE];
    int even_sum = 0, odd_sum = 0;

    // Efficient initialization and summation
    for (int i = 0; i < MAX_SIZE; i++) {
        numbers[i] = i + 1;

        // Conditional sum with minimal branching
        even_sum += (numbers[i] % 2 == 0) * numbers[i];
        odd_sum += (numbers[i] % 2!= 0) * numbers[i];
    }

    printf("Sum of Even Numbers: %d\n", even_sum);
    printf("Sum of Odd Numbers: %d\n", odd_sum);

    return 0;
}

Hauptsächlich demonstrierte Optimierungstechniken:

1. Schleifen-Ausrollen (Loop Unrolling) zur Reduzierung des Schleifen-Overheads
2. Minimierung von Branch-Predictions
3. Kombination von Initialisierung und Verarbeitung
4. Verwendung von Multiplikation für bedingte Summenbildung

Kompilieren und führen Sie die Programme mit Optimierungs-Flags aus:

## Compile with basic optimization
gcc -O2 loop_optimization.c -o loop_optimization
./loop_optimization

## Compile with advanced optimization
gcc -O3 loop_optimization.c -o loop_optimization
./loop_optimization

Zusätzliche Optimierungstipps:

• Verwenden Sie die Compiler-Flags -O2 oder -O3.
• Minimieren Sie Funktionsaufrufe innerhalb von Schleifen.
• Verwenden Sie geeignete Datentypen.
• Vermeiden Sie unnötige Berechnungen.
• Erwägen Sie die Bewegung von Schleifen-invarianten Code.

Zusammenfassung

In diesem Lab lernen Sie die Grundlagen von while-Schleifen in der C-Programmierung kennen, einschließlich der Verwendung der break- und continue-Direktiven zur Steuerung des Schleifenflusses. Sie werden auch Techniken zur Filterung von Array-Elementen mithilfe von bedingten Anweisungen und zur Optimierung der Schleifen-Effizienz mit verschiedenen Direktiven untersuchen. Am Ende dieses Labs werden Sie ein solides Verständnis davon haben, wie Sie bedingte Schleifen in C implementieren können, um eine Vielzahl von Programmierproblemen zu lösen.