Boucles conditionnelles en C

Introduction

Dans ce laboratoire, vous apprendrez à implémenter des boucles conditionnelles en programmation C. Vous commencerez par comprendre les bases des boucles while, puis explorerez l'utilisation des directives break et continue pour contrôler l'exécution des boucles. De plus, vous apprendrez à filtrer les éléments d'un tableau à l'aide d'instructions conditionnelles et à optimiser l'efficacité des boucles avec diverses directives. À la fin de ce laboratoire, vous aurez une solide compréhension des boucles conditionnelles et de leurs applications pratiques en programmation C.

Comprendre les boucles while

Dans cette étape, vous apprendrez les bases des boucles while en programmation C. Les boucles while sont des structures de contrôle puissantes qui vous permettent de répéter un bloc de code tant qu'une condition spécifique reste vraie.

Créons un simple programme C pour démontrer la syntaxe de base d'une boucle while. Ouvrez l'éditeur VSCode et créez un nouveau fichier appelé while_loop_example.c dans le répertoire ~/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;
}

Décortiquons le code :

• int count = 1; initialise une variable compteur
• while (count <= 5) crée une boucle qui continue tant que count est inférieur ou égal à 5
• printf() affiche la valeur actuelle de count
• count++ incrémente le compteur à chaque itération

Compilez et exécutez le programme :

gcc while_loop_example.c -o while_loop_example
./while_loop_example

Exemple de sortie :

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

Voici un autre exemple qui démontre une boucle while avec une entrée utilisateur :

#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;
}

Cet exemple montre comment les boucles while peuvent être utilisées pour une entrée interactive, en continuant jusqu'à ce qu'une condition spécifique (saisir 0) soit remplie.

Appliquer la directive break dans les boucles while

Dans cette étape, vous apprendrez à propos de la directive break en programmation C, qui vous permet de sortir prématurément d'une boucle lorsqu'une condition spécifique est remplie. L'instruction break offre un moyen de terminer immédiatement la boucle actuelle et de continuer l'exécution avec l'instruction suivante après la boucle.

Créons un nouveau fichier appelé break_loop_example.c dans le répertoire ~/project pour démontrer l'utilisation de break :

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;
}

Décortiquons le code :

• while (1) crée une boucle infinie qui continuera jusqu'à ce qu'une instruction break soit rencontrée
• Lorsque l'utilisateur entre un nombre divisible par 10, l'instruction break sort immédiatement de la boucle
• Si le nombre n'est pas divisible par 10, la boucle continue de demander une entrée

Voici un autre exemple qui démontre break dans un scénario plus complexe :

#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;
}

Cet exemple montre comment break peut être utilisé pour :

• Arrêter la collecte d'entrées lorsqu'une condition spécifique est remplie
• Calculer la moyenne des nombres entrés
• Offrir de la flexibilité dans la terminaison de la boucle

Compilez et exécutez les programmes pour voir comment fonctionne la directive break :

gcc break_loop_example.c -o break_loop_example
./break_loop_example

Utiliser la directive continue dans les boucles while

Dans cette étape, vous apprendrez à propos de la directive continue en programmation C, qui vous permet de sauter l'itération actuelle d'une boucle et de passer à l'itération suivante. L'instruction continue offre un moyen d'exécuter ou de sauter sélectivement des parties d'une boucle en fonction de conditions spécifiques.

Créons un nouveau fichier appelé continue_loop_example.c dans le répertoire ~/project pour démontrer l'utilisation de continue :

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;
}

Décortiquons le code :

• Le programme demande à l'utilisateur d'entrer 10 nombres
• if (number % 2!= 0) vérifie si le nombre est impair
• continue saute le reste de l'itération actuelle pour les nombres impairs
• Seuls les nombres pairs sont ajoutés à la somme et comptabilisés

Voici un autre exemple qui démontre continue avec des conditions plus complexes :

#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;
}

Cet exemple montre comment continue peut être utilisé pour :

• Sauter des valeurs spécifiques
• Traiter sélectivement des nombres en fonction de conditions
• Offrir un contrôle de boucle plus flexible

Compilez et exécutez les programmes pour voir comment fonctionne la directive continue :

gcc continue_loop_example.c -o continue_loop_example
./continue_loop_example

Filtrer les éléments d'un tableau avec des instructions conditionnelles

Dans cette étape, vous apprendrez à filtrer les éléments d'un tableau en utilisant des instructions conditionnelles et des boucles en programmation C. Le filtrage vous permet de sélectionner des éléments spécifiques d'un tableau en fonction de certaines conditions.

Créons un nouveau fichier appelé array_filtering.c dans le répertoire ~/project pour démontrer le filtrage des éléments d'un tableau :

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;
}

Décortiquons le processus de filtrage :

• Nous créons deux tableaux : numbers pour stocker les entrées et filtered_even pour stocker les éléments filtrés
• La première boucle lit 10 nombres de l'utilisateur
• La deuxième boucle utilise une instruction conditionnelle pour filtrer les nombres pairs
• if (numbers[i] % 2 == 0) vérifie si un nombre est pair
• Les éléments correspondants sont stockés dans le tableau filtered_even

Voici un exemple plus complexe avec plusieurs conditions de filtrage :

#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;
}

Cet exemple démontre :

• Le filtrage des nombres premiers à partir d'un tableau d'entrée
• L'utilisation de boucles imbriquées pour vérifier la primalité
• Le stockage des éléments filtrés dans un tableau séparé

Compilez et exécutez les programmes :

gcc array_filtering.c -o array_filtering
./array_filtering

Exemple d'entrée et de sortie :

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

Optimiser l'efficacité des boucles avec des directives

Dans cette étape, vous apprendrez des techniques pour optimiser l'efficacité des boucles en programmation C en utilisant diverses directives et stratégies. Nous explorerons différentes approches pour améliorer les performances et la lisibilité des boucles.

Créons un fichier appelé loop_optimization.c dans le répertoire ~/project pour démontrer les techniques d'optimisation :

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;
}

Voici un autre exemple démontrant plusieurs techniques d'optimisation :

#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;
}

Principales techniques d'optimisation démontrées :

1. Découpage de boucle (loop unrolling) pour réduire la surcharge des boucles
2. Minimisation des prédictions de branchement
3. Combinaison de l'initialisation et du traitement
4. Utilisation de la multiplication pour la sommation conditionnelle

Compilez et exécutez les programmes avec des indicateurs d'optimisation :

## 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

Conseils supplémentaires d'optimisation :

• Utilisez les indicateurs de compilateur -O2 ou -O3
• Minimisez les appels de fonction à l'intérieur des boucles
• Utilisez des types de données appropriés
• Évitez les calculs inutiles
• Considérez le déplacement de code invariant dans la boucle

Résumé

Dans ce laboratoire, vous apprendrez les bases des boucles while en programmation C, notamment comment utiliser les directives break et continue pour contrôler le flux de la boucle. Vous explorerez également des techniques de filtrage des éléments d'un tableau à l'aide d'instructions conditionnelles et d'optimisation de l'efficacité des boucles avec diverses directives. À la fin de ce laboratoire, vous aurez une bonne compréhension de la mise en œuvre de boucles conditionnelles en C pour résoudre une variété de problèmes de programmation.