Créer une calculatrice de factorielle en C

Introduction

Dans ce laboratoire (lab), vous apprendrez à créer une calculatrice de factorielle en langage de programmation C. Le laboratoire couvre des sujets essentiels tels que la compréhension de la syntaxe des boucles for, l'itération sur les éléments d'un tableau, la mise en œuvre du calcul de la factorielle, la gestion des cas limites, ainsi que le test et le débogage de la calculatrice de factorielle. À la fin de ce laboratoire, vous aurez une solide compréhension de ces concepts de programmation fondamentaux et pourrez les appliquer pour construire une calculatrice de factorielle fonctionnelle.

Le laboratoire fournit des instructions étape par étape et des exemples de code pour vous guider tout au long du processus de création de la calculatrice de factorielle. Vous commencerez par apprendre la syntaxe de base des boucles for, qui sont cruciales pour parcourir des tableaux et effectuer des tâches répétitives. Ensuite, vous explorerez comment accéder et manipuler les éléments d'un tableau, ce qui est essentiel pour le calcul de la factorielle. Le laboratoire couvrira également la mise en œuvre du calcul de la factorielle, la gestion des cas limites, ainsi que le test et le débogage du programme final.

Skills Graph

Comprendre la syntaxe des boucles for

Dans cette étape, vous apprendrez la syntaxe fondamentale des boucles for en programmation C, qui sont essentielles pour parcourir des tableaux et effectuer des tâches répétitives telles que le calcul de factorielle.

Commençons par créer un simple programme C pour démontrer la syntaxe de base des boucles for. Ouvrez le WebIDE et créez un nouveau fichier nommé loop_example.c dans le répertoire ~/project :

cd ~/project
touch loop_example.c

#include <stdio.h>

int main() {
    // Basic for loop syntax: for (initialization; condition; increment/decrement)
    for (int i = 0; i < 5; i++) {
        printf("Current iteration: %d\n", i);
    }
    return 0;
}

Exemple de sortie :

Current iteration: 0
Current iteration: 1
Current iteration: 2
Current iteration: 3
Current iteration: 4

Décortiquons la syntaxe de la boucle for :

• int i = 0 : Initialisation - définit la variable compteur de boucle à une valeur initiale
• i < 5 : Condition - continue la boucle tant que cette condition est vraie
• i++ : Incrémentation - augmente le compteur de boucle après chaque itération

Maintenant, compilez et exécutez le programme pour voir comment fonctionne la boucle :

gcc loop_example.c -o loop_example
./loop_example

La boucle for est puissante car elle vous permet de contrôler précisément le processus d'itération. Vous pouvez modifier les parties d'initialisation, de condition et d'incrémentation/décrémentation pour répondre à différents besoins de programmation, comme parcourir des tableaux ou effectuer des calculs.

Itérer sur les éléments d'un tableau

Dans cette étape, vous apprendrez à itérer sur les éléments d'un tableau en C, ce qui est crucial pour implémenter notre calculatrice de factorielle. En vous appuyant sur les connaissances des boucles for acquises à l'étape précédente, nous allons explorer comment accéder et manipuler les éléments d'un tableau.

Créons un nouveau fichier appelé array_iteration.c dans le répertoire ~/project pour démontrer l'itération sur un tableau :

cd ~/project
touch array_iteration.c

#include <stdio.h>

int main() {
    // Declare and initialize an array of integers
    int numbers[5] = {10, 20, 30, 40, 50};

    // Iterate through the array using a for loop
    for (int i = 0; i < 5; i++) {
        printf("Element at index %d is: %d\n", i, numbers[i]);
    }

    return 0;
}

Exemple de sortie :

Element at index 0 is: 10
Element at index 1 is: 20
Element at index 2 is: 30
Element at index 3 is: 40
Element at index 4 is: 50

Décortiquons les concepts clés :

• int numbers[5] crée un tableau pouvant contenir 5 éléments entiers
• {10, 20, 30, 40, 50} initialise le tableau avec des valeurs spécifiques
• numbers[i] accède aux éléments individuels du tableau en utilisant l'indice
• La boucle for utilise i comme indice pour accéder séquentiellement à chaque élément

Maintenant, compilez et exécutez le programme :

gcc array_iteration.c -o array_iteration
./array_iteration

Pour rendre l'itération plus pratique, créons un exemple qui calcule la somme des éléments d'un tableau :

#include <stdio.h>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    int sum = 0;

    // Calculate sum using array iteration
    for (int i = 0; i < 5; i++) {
        sum += numbers[i];
    }

    printf("Sum of array elements: %d\n", sum);

    return 0;
}

Exemple de sortie :

Sum of array elements: 150

Cela démontre comment vous pouvez utiliser des boucles for pour effectuer des opérations sur les éléments d'un tableau, ce qui sera crucial dans l'implémentation de notre calculatrice de factorielle à venir.

Implémenter le calcul de la factorielle

Dans cette étape, vous apprendrez à implémenter une fonction de calcul de factorielle en C en utilisant les techniques d'itération de boucle que vous avez apprises dans les étapes précédentes. La factorielle est une opération mathématique qui multiplie un nombre par tous les entiers positifs inférieurs à lui.

Créons un nouveau fichier appelé factorial_calculator.c dans le répertoire ~/project :

cd ~/project
touch factorial_calculator.c

#include <stdio.h>

// Function to calculate factorial
int calculateFactorial(int n) {
    // Initialize result to 1
    int factorial = 1;

    // Use for loop to multiply numbers from 1 to n
    for (int i = 1; i <= n; i++) {
        factorial *= i;
    }

    return factorial;
}

int main() {
    // Test factorial calculation for different numbers
    int numbers[] = {0, 1, 5, 7};

    // Iterate through the numbers and calculate their factorials
    for (int j = 0; j < 4; j++) {
        int num = numbers[j];
        int result = calculateFactorial(num);

        printf("Factorial of %d is: %d\n", num, result);
    }

    return 0;
}

Exemple de sortie :

Factorial of 0 is: 1
Factorial of 1 is: 1
Factorial of 5 is: 120
Factorial of 7 is: 5040

Décortiquons le calcul de la factorielle :

• La factorielle de 0 et de 1 est 1
• La factorielle de n (n!) = 1 _ 2 _ 3 _... _ n
• La fonction calculateFactorial() utilise une boucle for pour multiplier les nombres
• Nous commençons la factorielle à 1 et multiplions par chaque nombre jusqu'à n

Compilez et exécutez le programme :

gcc factorial_calculator.c -o factorial_calculator
./factorial_calculator

Pour rendre la calculatrice plus interactive, modifions le programme pour accepter une entrée utilisateur :

#include <stdio.h>

int calculateFactorial(int n) {
    int factorial = 1;
    for (int i = 1; i <= n; i++) {
        factorial *= i;
    }
    return factorial;
}

int main() {
    int number;

    // Prompt user for input
    printf("Enter a number to calculate its factorial: ");
    scanf("%d", &number);

    // Calculate and display factorial
    int result = calculateFactorial(number);
    printf("Factorial of %d is: %d\n", number, result);

    return 0;
}

Exemple d'interaction :

Enter a number to calculate its factorial: 6
Factorial of 6 is: 720

Gérer les cas limites

Dans cette étape, vous apprendrez à gérer les cas limites dans votre calculatrice de factorielle, tels que les nombres négatifs et les entrées importantes qui pourraient entraîner un dépassement de capacité (overflow) d'entier. Une gestion d'erreurs robuste est cruciale pour créer un logiciel fiable.

Modifions notre calculatrice de factorielle pour gérer ces cas limites. Créez un nouveau fichier appelé factorial_edge_cases.c dans le répertoire ~/project :

cd ~/project
touch factorial_edge_cases.c

#include <stdio.h>
#include <limits.h>

// Function to calculate factorial with error handling
int calculateFactorial(int n) {
    // Check for negative numbers
    if (n < 0) {
        printf("Error: Factorial is not defined for negative numbers.\n");
        return -1;
    }

    // Initialize result to 1
    int factorial = 1;

    // Check for potential integer overflow
    for (int i = 1; i <= n; i++) {
        // Check if multiplication will cause overflow
        if (factorial > INT_MAX / i) {
            printf("Error: Factorial result exceeds integer limit.\n");
            return -1;
        }
        factorial *= i;
    }

    return factorial;
}

int main() {
    // Test various edge cases
    int test_cases[] = {-5, 0, 1, 12, 13};

    for (int i = 0; i < 5; i++) {
        int number = test_cases[i];
        int result = calculateFactorial(number);

        // Only print result if calculation was successful
        if (result!= -1) {
            printf("Factorial of %d is: %d\n", number, result);
        }
    }

    return 0;
}

Exemple de sortie :

Error: Factorial is not defined for negative numbers.
Factorial of 0 is: 1
Factorial of 1 is: 1
Factorial of 12 is: 479001600
Error: Factorial result exceeds integer limit.

Techniques clés de gestion d'erreurs :

• Vérifier les nombres négatifs avant le calcul
• Utiliser INT_MAX pour éviter le dépassement de capacité d'entier
• Retourner -1 pour indiquer une erreur de calcul
• Fournir des messages d'erreur informatifs

Compilez et exécutez le programme :

gcc factorial_edge_cases.c -o factorial_edge_cases
./factorial_edge_cases

Améliorons le programme avec une gestion d'entrée plus conviviale pour l'utilisateur :

#include <stdio.h>
#include <limits.h>

int calculateFactorial(int n) {
    if (n < 0) {
        printf("Error: Factorial is not defined for negative numbers.\n");
        return -1;
    }

    int factorial = 1;

    for (int i = 1; i <= n; i++) {
        if (factorial > INT_MAX / i) {
            printf("Error: Factorial result exceeds integer limit.\n");
            return -1;
        }
        factorial *= i;
    }

    return factorial;
}

int main() {
    int number;

    while (1) {
        printf("Enter a non-negative integer (or negative to exit): ");

        // Check if input is valid
        if (scanf("%d", &number)!= 1) {
            printf("Invalid input. Please enter an integer.\n");
            // Clear input buffer
            while (getchar()!= '\n');
            continue;
        }

        // Exit condition
        if (number < 0) {
            printf("Exiting factorial calculator.\n");
            break;
        }

        // Calculate and display factorial
        int result = calculateFactorial(number);
        if (result!= -1) {
            printf("Factorial of %d is: %d\n", number, result);
        }
    }

    return 0;
}

Exemple d'interaction :

Enter a non-negative integer (or negative to exit): 10
Factorial of 10 is: 3628800
Enter a non-negative integer (or negative to exit): -1
Exiting factorial calculator.

Tester et déboguer la calculatrice de factorielle

Dans cette étape finale, vous apprendrez à tester et déboguer minutieusement votre calculatrice de factorielle en utilisant diverses techniques de test et stratégies de débogage.

Créons un programme de test complet qui inclut de multiples cas de test et des fonctionnalités de débogage. Créez un fichier nommé factorial_test.c dans le répertoire ~/project :

cd ~/project
touch factorial_test.c

#include <stdio.h>
#include <assert.h>
#include <limits.h>

// Factorial calculation function with detailed error checking
int calculateFactorial(int n) {
    // Debug print to track function calls
    printf("DEBUG: Calculating factorial for %d\n", n);

    // Validate input range
    if (n < 0) {
        fprintf(stderr, "ERROR: Factorial undefined for negative numbers\n");
        return -1;
    }

    // Handle special cases
    if (n == 0 || n == 1) return 1;

    // Factorial calculation with overflow protection
    long long factorial = 1;
    for (int i = 2; i <= n; i++) {
        factorial *= i;

        // Overflow check
        if (factorial > INT_MAX) {
            fprintf(stderr, "ERROR: Factorial exceeds integer limit\n");
            return -1;
        }
    }

    return (int)factorial;
}

// Test function to verify factorial calculations
void runTests() {
    // Test cases with expected results
    struct TestCase {
        int input;
        int expected;
    } tests[] = {
        {0, 1},    // Edge case: 0!
        {1, 1},    // Edge case: 1!
        {5, 120},  // Normal case: 5!
        {10, 3628800}  // Larger number
    };

    int numTests = sizeof(tests) / sizeof(tests[0]);

    printf("Running %d test cases...\n", numTests);

    // Iterate through test cases
    for (int i = 0; i < numTests; i++) {
        int result = calculateFactorial(tests[i].input);

        // Assertion-style testing
        if (result == tests[i].expected) {
            printf("Test case %d PASSED: factorial(%d) = %d\n",
                   i+1, tests[i].input, result);
        } else {
            printf("Test case %d FAILED: Expected %d, Got %d\n",
                   i+1, tests[i].expected, result);
        }
    }
}

int main() {
    // Run comprehensive test suite
    runTests();

    // Interactive testing mode
    int number;
    printf("\nEnter a number to calculate its factorial (or negative to exit): ");
    while (scanf("%d", &number) == 1 && number >= 0) {
        int result = calculateFactorial(number);
        if (result!= -1) {
            printf("Factorial of %d is: %d\n", number, result);
        }

        printf("\nEnter another number (or negative to exit): ");
    }

    return 0;
}

Compilez et exécutez le programme :

gcc factorial_test.c -o factorial_test
./factorial_test

Un exemple de sortie ressemblera à ceci :

Running 4 test cases...
DEBUG: Calculating factorial for 0
Test case 1 PASSED: factorial(0) = 1
DEBUG: Calculating factorial for 1
Test case 2 PASSED: factorial(1) = 1
DEBUG: Calculating factorial for 5
Test case 3 PASSED: factorial(5) = 120
DEBUG: Calculating factorial for 10
Test case 4 PASSED: factorial(10) = 3628800

Enter a number to calculate its factorial (or negative to exit):

Techniques clés de débogage et de test démontrées :

• Instructions d'impression de débogage pour suivre l'exécution des fonctions
• Cas de test complets couvrant les cas limites
• Gestion des erreurs pour les entrées invalides
• Protection contre le dépassement de capacité (overflow)
• Test de type assertion
• Mode de test interactif

Conseils de débogage :

1. Utilisez printf() pour la journalisation et le suivi des appels de fonction
2. Gérez explicitement les cas limites
3. Implémentez la validation des entrées
4. Utilisez long long pour les calculs avec de plus grands nombres
5. Créez une suite de tests pour vérifier différents scénarios

Résumé

Dans ce laboratoire, vous avez appris la syntaxe fondamentale des boucles for en programmation C, qui sont essentielles pour parcourir des tableaux et effectuer des tâches répétitives telles que le calcul de factorielle. Vous avez également exploré comment itérer sur les éléments d'un tableau, ce qui est crucial pour implémenter la calculatrice de factorielle.

Vous avez commencé par créer un simple programme C pour démontrer la syntaxe de base des boucles for, en comprenant les parties d'initialisation, de condition et d'incrémentation/décrémentation de la boucle. Ensuite, vous avez appris à parcourir un tableau d'entiers à l'aide d'une boucle for, en accédant et en manipulant les éléments du tableau.