Déterminer si un nombre est un entier ou un flottant en C

Introduction

Dans ce laboratoire (lab), nous allons écrire un programme en langage C qui permet d'identifier si un nombre saisi par l'utilisateur est un entier ou un nombre à virgule flottante (float). Il s'agit d'un concept fondamental en programmation, car différents types de données ont des exigences mémoire et des comportements différents.

Nous allons nous concentrer sur la détection de la présence d'un point décimal dans l'entrée pour déterminer si le nombre est une valeur à virgule flottante. Ce laboratoire vous introduit à la manipulation de chaînes de caractères de base en C, au traitement des entrées utilisateur et à la logique conditionnelle.

À la fin de ce laboratoire, vous comprendrez comment :

• Lire l'entrée utilisateur sous forme de chaîne de caractères en C
• Vérifier la présence de caractères spécifiques dans une chaîne de caractères
• Utiliser la logique conditionnelle pour prendre des décisions en fonction de l'entrée

Skills Graph

Créer et ouvrir le fichier de programme C

Commençons par créer un nouveau fichier C pour notre programme. Nous allons le nommer main.c et le placer dans le répertoire du projet.

1. Tout d'abord, assurez-vous d'être dans le répertoire du projet :

cd ~/project

2. Maintenant, dans le WebIDE, cliquez sur le menu "File" (Fichier), sélectionnez "New File" (Nouveau fichier) et nommez-le main.c. Alternativement, vous pouvez utiliser l'icône "New File" (Nouveau fichier) dans la barre latérale de l'explorateur de fichiers.

3. L'éditeur de fichier s'ouvrira automatiquement. Ajoutons les fichiers d'en-tête requis à notre programme :

#include <stdio.h>
#include <string.h>

Ces fichiers d'en-tête sont essentiels pour notre programme :

• stdio.h fournit des fonctions pour les opérations d'entrée et de sortie standard telles que printf() et scanf().
• string.h fournit des fonctions pour la manipulation de chaînes de caractères. Bien que dans ce simple programme, nous l'utilisions principalement pour le calcul de la longueur des chaînes.

Notez que nous n'avons pas inclus conio.h comme mentionné dans le modèle original. En effet, conio.h n'est pas une bibliothèque standard C et n'est pas disponible sur de nombreux systèmes, y compris notre environnement Ubuntu.

Ajout de la fonction principale et déclaration des variables

Maintenant que nous avons nos fichiers d'en-tête, ajoutons la fonction main() et déclarons les variables dont nous aurons besoin pour notre programme.

Ajoutez le code suivant à votre fichier main.c :

int main() {
    char number[20];  // Array to store the input number as a string
    int flag = 0;     // Flag to track if a decimal point is found (0 = not found, 1 = found)
    int i;            // Loop counter variable

    // Program will continue here...

    return 0;
}

Comprenons ces variables :

• number[20] : Il s'agit d'un tableau de caractères (chaîne de caractères) qui stockera l'entrée de l'utilisateur. Nous avons augmenté la taille à 20 caractères pour pouvoir gérer des nombres plus grands.
• flag : Cette variable entière agira comme un indicateur booléen. Si nous trouvons un point décimal dans l'entrée, nous l'affecterons à 1.
• i : Une simple variable compteur pour notre boucle.

La fonction main() est le point d'entrée de notre programme en C. Tout le code que nous écrivons sera à l'intérieur de cette fonction. L'instruction return 0 à la fin indique que le programme s'est exécuté avec succès.

Votre fichier devrait maintenant ressembler à ceci :

#include <stdio.h>
#include <string.h>

int main() {
    char number[20];  // Array to store the input number as a string
    int flag = 0;     // Flag to track if a decimal point is found (0 = not found, 1 = found)
    int i;            // Loop counter variable

    // Program will continue here...

    return 0;
}

Mise en œuvre de la logique du programme

Maintenant, ajoutons le code restant pour lire l'entrée de l'utilisateur et déterminer si le nombre est un entier ou un nombre à virgule flottante.

Remplacez le commentaire "Program will continue here..." par le code suivant :

    // Prompt the user to enter a number
    printf("Enter a number: ");
    scanf("%s", number);

    // Check each character in the number string for a decimal point
    for(i = 0; number[i] != '\0'; i++) {
        if(number[i] == '.') {
            flag = 1;  // Set flag to 1 if decimal point is found
            break;
        }
    }

    // Display the result based on the flag value
    if(flag) {
        printf("The entered number is a floating point number.\n");
    } else {
        printf("The entered number is an integer number.\n");
    }

Examinons ce que fait ce code :

1. L'instruction printf() affiche une invite demandant à l'utilisateur d'entrer un nombre.
2. La fonction scanf() lit l'entrée de l'utilisateur sous forme de chaîne de caractères et la stocke dans le tableau number.
3. Nous utilisons une boucle for pour parcourir chaque caractère de la chaîne jusqu'à ce que nous atteignions le caractère de fin de chaîne ('\0').
4. À l'intérieur de la boucle, nous vérifions si chaque caractère est un point décimal ('.'). Si c'est le cas, nous affectons la valeur 1 au flag et nous sortons de la boucle.
5. Enfin, nous utilisons une instruction if pour vérifier si le flag est activé. Si c'est le cas, nous informons l'utilisateur que le nombre est un nombre à virgule flottante ; sinon, c'est un entier.

Votre programme complet devrait maintenant ressembler à ceci :

#include <stdio.h>
#include <string.h>

int main() {
    char number[20];  // Array to store the input number as a string
    int flag = 0;     // Flag to track if a decimal point is found (0 = not found, 1 = found)
    int i;            // Loop counter variable

    // Prompt the user to enter a number
    printf("Enter a number: ");
    scanf("%s", number);

    // Check each character in the number string for a decimal point
    for(i = 0; number[i] != '\0'; i++) {
        if(number[i] == '.') {
            flag = 1;  // Set flag to 1 if decimal point is found
            break;
        }
    }

    // Display the result based on the flag value
    if(flag) {
        printf("The entered number is a floating point number.\n");
    } else {
        printf("The entered number is an integer number.\n");
    }

    return 0;
}

Compilation et exécution du programme

Maintenant que nous avons écrit notre programme, compilons-le et exécutons-le pour le voir en action.

1. Tout d'abord, enregistrez le fichier si vous ne l'avez pas déjà fait (Ctrl+S ou Fichier > Enregistrer).

2. Ouvrez un terminal dans le WebIDE (s'il n'est pas déjà ouvert).

3. Accédez au répertoire du projet et compilez le programme en utilisant le compilateur GCC :

cd ~/project
gcc main.c -o main

La commande gcc compile notre fichier source C, et l'option -o main spécifie que l'exécutable de sortie doit être nommé main.

4. Exécutez maintenant le programme compilé :

./main

5. Lorsque vous êtes invité, entrez un nombre. Essayez d'abord un entier, comme 42 :

Enter a number: 42

Vous devriez voir la sortie suivante :

The entered number is an integer number.

6. Exécutez le programme à nouveau et essayez un nombre à virgule flottante comme 3.14 :

./main

Enter a number: 3.14

Vous devriez voir la sortie suivante :

The entered number is a floating point number.

Le programme identifie correctement les entiers et les nombres à virgule flottante en fonction de la présence d'un point décimal dans l'entrée.

Amélioration du programme

Améliorons notre programme pour le rendre plus convivial et robuste. Nous allons ajouter une boucle afin que l'utilisateur puisse vérifier plusieurs nombres sans redémarrer le programme, et nous allons également ajouter une validation des entrées.

Mettez à jour votre fichier main.c avec le code suivant :

#include <stdio.h>
#include <string.h>
#include <ctype.h>  // Pour la fonction isdigit

int main() {
    char number[20];
    int flag, i;
    char choice;

    do {
        flag = 0;  // Réinitialiser le drapeau pour chaque itération

        // Inviter l'utilisateur à entrer un nombre
        printf("\nEnter a number: ");
        scanf("%s", number);

        // Validation de l'entrée - vérifier si l'entrée ne contient que des chiffres et au plus un point décimal
        int valid = 1;
        int decimal_count = 0;

        for(i = 0; number[i] != '\0'; i++) {
            if(number[i] == '.') {
                decimal_count++;
                if(decimal_count > 1) {
                    valid = 0;
                    break;
                }
            } else if(!isdigit(number[i])) {
                valid = 0;
                break;
            }
        }

        if(!valid) {
            printf("Invalid input! Please enter a valid number.\n");
            continue;
        }

        // Vérifier si le nombre est un entier ou un nombre à virgule flottante
        for(i = 0; number[i] != '\0'; i++) {
            if(number[i] == '.') {
                flag = 1;
                break;
            }
        }

        // Afficher le résultat
        if(flag) {
            printf("The entered number is a floating point number.\n");
        } else {
            printf("The entered number is an integer number.\n");
        }

        // Demander à l'utilisateur s'il souhaite continuer
        printf("\nDo you want to check another number? (y/n): ");
        scanf(" %c", &choice);

    } while(choice == 'y' || choice == 'Y');

    printf("\nThank you for using the program!\n");
    return 0;
}

Cette version améliorée inclut :

1. Une boucle do-while qui permet à l'utilisateur de vérifier plusieurs nombres.
2. Une validation des entrées pour s'assurer que l'entrée ne contient que des chiffres et au plus un point décimal.
3. Une interface plus conviviale avec des invites et des retours d'information plus clairs.

Compilez et exécutez cette version améliorée :

cd ~/project
gcc main.c -o main
./main

Testez-le avec diverses entrées, notamment :

• Des nombres entiers comme 42
• Des nombres à virgule flottante comme 3.14
• Des entrées invalides comme abc ou 1.2.3

Le programme devrait gérer correctement tous ces cas et vous permettre de continuer à vérifier des nombres jusqu'à ce que vous choisissiez de quitter.

Résumé

Dans ce laboratoire, vous avez créé avec succès un programme en langage C permettant de déterminer si un nombre saisi par l'utilisateur est un entier ou un nombre à virgule flottante. Voici les concepts clés que vous avez appris :

1. Gestion des chaînes de caractères en C : Vous avez utilisé des tableaux de caractères pour stocker et traiter des données sous forme de chaînes de caractères, en parcourant chaque caractère pour vérifier ses propriétés.

2. Traitement des entrées utilisateur : Vous avez appris à demander et à lire les entrées de l'utilisateur à l'aide de la fonction scanf().

3. Structures de contrôle : Vous avez mis en œuvre des instructions conditionnelles (if-else) et des boucles (for, do-while) pour contrôler le flux de votre programme.

4. Validation des entrées : Dans la version améliorée, vous avez ajouté des vérifications pour vous assurer que l'entrée de l'utilisateur est un nombre valide.

5. Amélioration du programme : Vous avez amélioré le programme de base en ajoutant des fonctionnalités telles qu'une boucle utilisateur et une validation des entrées, le rendant ainsi plus robuste et plus convivial.

Ces concepts sont fondamentaux pour de nombreuses tâches de programmation et constitueront une solide base pour votre apprentissage continu du langage C. La capacité à distinguer différents types de données est particulièrement importante dans les langages fortement typés comme le C, où différents types de données ont des allocations mémoire et des comportements différents.