Conversion Hexadécimal en Binaire en Langage C : Exercices Corrigés et Cas Particuliers

La conversion des nombres hexadécimaux en binaire est une compétence essentielle en programmation, notamment en C. Cet article vise à fournir une explication détaillée de cette conversion, suivie d’exercices corrigés et de cas particuliers pour renforcer la compréhension.

1. Introduction à la Conversion Hexadécimal en Binaire

Les nombres hexadécimaux (base 16) sont couramment utilisés en informatique en raison de leur efficacité pour représenter des nombres binaires (base 2). Chaque chiffre hexadécimal correspond exactement à quatre bits binaires.

Table de Correspondance

2. Conversion Manuelle

Pour convertir un nombre hexadécimal en binaire, il suffit de remplacer chaque chiffre hexadécimal par son équivalent binaire à 4 bits.

Exemple : Convertir 2F3 en binaire.

1. 2 en binaire est 0010
2. F en binaire est 1111
3. 3 en binaire est 0011

Donc, 2F3 en hexadécimal est 0010 1111 0011 en binaire.

3. Programme en Langage C

Voici un programme en C qui effectue la conversion d’un nombre hexadécimal en binaire.

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

void hexToBinary(char hex[]) {
    int i = 0;
    printf("Binaire: ");
    while (hex[i]) {
        switch (hex[i]) {
            case '0': printf("0000"); break;
            case '1': printf("0001"); break;
            case '2': printf("0010"); break;
            case '3': printf("0011"); break;
            case '4': printf("0100"); break;
            case '5': printf("0101"); break;
            case '6': printf("0110"); break;
            case '7': printf("0111"); break;
            case '8': printf("1000"); break;
            case '9': printf("1001"); break;
            case 'A':
            case 'a': printf("1010"); break;
            case 'B':
            case 'b': printf("1011"); break;
            case 'C':
            case 'c': printf("1100"); break;
            case 'D':
            case 'd': printf("1101"); break;
            case 'E':
            case 'e': printf("1110"); break;
            case 'F':
            case 'f': printf("1111"); break;
            default: printf("\nCaractère hexadécimal invalide %c", hex[i]);
        }
        i++;
    }
    printf("\n");
}

int main() {
    char hex[100];
    printf("Entrer un nombre hexadécimal: ");
    scanf("%s", hex);
    hexToBinary(hex);
    return 0;
}

4. Exercices Corrigés

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

int convertirHexVersBinaire(const char *hex)
{
    const char *table[16] = {
        "0000", "0001", "0010", "0011",
        "0100", "0101", "0110", "0111",
        "1000", "1001", "1010", "1011",
        "1100", "1101", "1110", "1111"
    };

    size_t i;

    if (hex == NULL || hex[0] == '\0') {
        printf("Erreur : entree vide.\n");
        return 0;
    }

    /* Première étape : validation complète */
    for (i = 0; hex[i] != '\0'; i++) {
        if (!isxdigit((unsigned char)hex[i])) {
            printf(
                "Erreur : caractere invalide '%c' a la position %zu.\n",
                hex[i],
                i + 1
            );
            return 0;
        }
    }

    /* Deuxième étape : conversion */
    printf("Binaire : ");

    for (i = 0; hex[i] != '\0'; i++) {
        unsigned char caractere =
            (unsigned char)toupper((unsigned char)hex[i]);

        int valeur;

        if (caractere >= '0' && caractere <= '9') {
            valeur = caractere - '0';
        } else {
            valeur = caractere - 'A' + 10;
        }

        printf("%s", table[valeur]);

        if (hex[i + 1] != '\0') {
            printf(" ");
        }
    }

    printf("\n");
    return 1;
}

int main(void)
{
    char nombreHex[101];

    printf("Entrez un nombre hexadecimal : ");

    if (scanf("%100s", nombreHex) != 1) {
        printf("Erreur de lecture.\n");
        return 1;
    }

    convertirHexVersBinaire(nombreHex);

    return 0;
}

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    const char *table[16] = {
        "0000", "0001", "0010", "0011",
        "0100", "0101", "0110", "0111",
        "1000", "1001", "1010", "1011",
        "1100", "1101", "1110", "1111"
    };

    char hex[101];
    int totalBitsUn = 0;
    int i;

    printf("Nombre hexadecimal : ");

    if (scanf("%100s", hex) != 1) {
        printf("Erreur de lecture.\n");
        return 1;
    }

    /* Validation */
    for (i = 0; hex[i] != '\0'; i++) {
        if (!isxdigit((unsigned char)hex[i])) {
            printf("Caractere invalide : %c\n", hex[i]);
            return 1;
        }
    }

    printf("Binaire : ");

    for (i = 0; hex[i] != '\0'; i++) {
        int valeur;
        int j;
        unsigned char c =
            (unsigned char)toupper((unsigned char)hex[i]);

        if (c >= '0' && c <= '9') {
            valeur = c - '0';
        } else {
            valeur = c - 'A' + 10;
        }

        printf("%s ", table[valeur]);

        for (j = 0; j < 4; j++) {
            if (table[valeur][j] == '1') {
                totalBitsUn++;
            }
        }
    }

    printf("\nNombre de bits a 1 : %d\n", totalBitsUn);

    return 0;
}

Références

Pour plus de lecture sur la conversion des systèmes de numération et la programmation en C, consultez les ressources suivantes :

1. Guide de programmation en C
2. Documentation sur les systèmes de numération

Exercices Avancés de Conversion Hexadécimale en Binaire en Langage C

Voici une série d’exercices avancés pour vous aider à maîtriser la conversion de nombres hexadécimaux en binaire en utilisant le langage de programmation C. Ces exercices comprennent des conversions directes, des manipulations de chaînes de caractères, et des cas particuliers qui vous permettront de consolider vos compétences.

Exercice 1 : Conversion de Longs Nombres Hexadécimaux

Question : Écrire un programme en C qui convertit un long nombre hexadécimal en binaire et affiche le résultat. Par exemple, convertir 1A3F4C2B en binaire.

Solution Attendue :

// Long hexadécimal : 1A3F4C2B
// Binaire attendu : 0001 1010 0011 1111 0100 1100 0010 1011

Exercice 2 : Conversion avec Validation

Question : Écrire un programme en C qui convertit un nombre hexadécimal en binaire. Le programme doit valider que l’entrée est bien un nombre hexadécimal valide (comprenant seulement les caractères 0-9, A-F, a-f) avant de faire la conversion.

Solution Attendue :

// Entrée : G45
// Sortie : Erreur, caractère invalide G

Exercice 3 : Conversion et Comptage de Bits

Question : Écrire un programme en C qui convertit un nombre hexadécimal en binaire et compte le nombre total de bits à 1 dans le résultat binaire.

Solution Attendue :

// Hexadécimal : 2F3
// Binaire : 0010 1111 0011
// Nombre de bits à 1 : 7

Exercice 4 : Conversion de Séquences Hexadécimales

Question : Écrire un programme en C qui lit une série de nombres hexadécimaux séparés par des virgules, les convertit en binaire, et affiche chaque conversion.

Solution Attendue :

// Entrée : 1A3,4F2,B3
// Sortie : 
// 1A3 -> 0001 1010 0011
// 4F2 -> 0100 1111 0010
// B3 -> 1011 0011

Exercice 5 : Conversion et Représentation Visuelle

Question : Écrire un programme en C qui convertit un nombre hexadécimal en binaire et affiche le résultat sous forme d’un tableau de bits. Utilisez des * pour représenter les bits à 1 et des . pour les bits à 0.

Solution Attendue :

// Hexadécimal : 9F
// Binaire : 1001 1111
// Tableau : 
// * . . .
// * * * *
// * . . .

Exercice 6 : Conversion et Opérations Bit à Bit

Question : Écrire un programme en C qui convertit deux nombres hexadécimaux en binaire, effectue une opération ET logique bit à bit entre les deux résultats binaires, et affiche le résultat de cette opération en binaire.

Solution Attendue :

// Hexadécimal 1 : A3 (1010 0011)
// Hexadécimal 2 : 5F (0101 1111)
// Résultat AND : 0000 0011

Exercice 7 : Conversion Inverse et Vérification

Question : Écrire un programme en C qui convertit un nombre hexadécimal en binaire, puis reconvertit ce nombre binaire en hexadécimal pour vérifier l’exactitude de la conversion initiale.

Solution Attendue :

// Hexadécimal : 4C
// Binaire : 0100 1100
// Hexadécimal reconverti : 4C
// Vérification : Réussi

Exercice 8 : Conversion et Opérations de Décalage

Question : Écrire un programme en C qui convertit un nombre hexadécimal en binaire, effectue un décalage logique vers la gauche de deux bits sur le résultat binaire, et affiche le nouveau résultat en binaire.

Solution Attendue :

// Hexadécimal : 3A (0011 1010)
// Binaire décalé : 1110 1000

Cas Particuliers et Questions Piège de Conversion Hexadécimale en Binaire en Langage C

La conversion de nombres hexadécimaux en binaire peut sembler directe, mais il existe des cas particuliers et des pièges courants qui peuvent compliquer la tâche. Voici une série de cas particuliers et de questions piège pour tester et renforcer votre compréhension.

Cas Particuliers

Nombres Hexadécimaux avec des Zéros Initiaux

• Question : Convertir 004F en binaire.
• Solution Attendue : 004F en hexadécimal est 0000 0000 0100 1111 en binaire.

Lettres Minuscules dans les Nombres Hexadécimaux

• Question : Convertir aBcD en binaire.
• Solution Attendue : aBcD en hexadécimal est 1010 1011 1100 1101 en binaire.

Nombres Hexadécimaux Composés Uniquement de Lettres

• Question : Convertir ABCD en binaire.
• Solution Attendue : ABCD en hexadécimal est 1010 1011 1100 1101 en binaire.

Nombres Hexadécimaux Très Longs

• Question : Convertir 123456789ABCDEF en binaire.
• Solution Attendue : 123456789ABCDEF en hexadécimal est 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 en binaire.

Questions Piège

Validation des Entrées Hexadécimales

• Question : Convertir G4H2 en binaire.
• Piège : G et H ne sont pas des caractères hexadécimaux valides.
• Solution Attendue : Le programme doit afficher une erreur pour les caractères invalides.

Combinaison de Zéros et de Lettres

• Question : Convertir 00AB en binaire.
• Piège : Ne pas ignorer les zéros initiaux.
• Solution Attendue : 00AB en hexadécimal est 0000 0000 1010 1011 en binaire.

Nombres Hexadécimaux avec des Espaces

• Question : Convertir 1 2 3 en binaire.
• Piège : Les espaces doivent être ignorés ou considérés comme des séparateurs incorrects.
• Solution Attendue : Le programme doit afficher une erreur ou supprimer les espaces avant la conversion.

Caractères Mixtes et Non-Hexadécimaux

• Question : Convertir 12G3H4 en binaire.
• Piège : Mélange de caractères hexadécimaux et non-hexadécimaux.
• Solution Attendue : Le programme doit afficher une erreur pour les caractères G et H.

Conversion de Chaînes Vidées

• Question : Convertir une chaîne vide en binaire.
• Piège : Gérer les entrées vides.
• Solution Attendue : Le programme doit afficher une erreur ou un message indiquant que l’entrée est vide.

Nombres Hexadécimaux avec des Caractères Spéciaux

• Question : Convertir 1A#C en binaire.
• Piège : Les caractères spéciaux comme # ne sont pas valides.
• Solution Attendue : Le programme doit afficher une erreur pour le caractère #.

Conversion de Nombres Négatifs (Invalide en Hexadécimal)

• Question : Convertir -2A3 en binaire.
• Piège : Les nombres négatifs ne sont pas valides en notation hexadécimale classique.
• Solution Attendue : Le programme doit afficher une erreur pour le signe -.

Programme de Démonstration en C pour Gérer les Cas Particuliers

Voici un programme en C qui prend en compte certains de ces cas particuliers et pièges.

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

void hexToBinary(char hex[]) {
    int i = 0;
    printf("Binaire: ");
    while (hex[i]) {
        if (!isxdigit(hex[i])) {
            printf("\nErreur: Caractère hexadécimal invalide %c\n", hex[i]);
            return;
        }
        switch (toupper(hex[i])) {
            case '0': printf("0000 "); break;
            case '1': printf("0001 "); break;
            case '2': printf("0010 "); break;
            case '3': printf("0011 "); break;
            case '4': printf("0100 "); break;
            case '5': printf("0101 "); break;
            case '6': printf("0110 "); break;
            case '7': printf("0111 "); break;
            case '8': printf("1000 "); break;
            case '9': printf("1001 "); break;
            case 'A': printf("1010 "); break;
            case 'B': printf("1011 "); break;
            case 'C': printf("1100 "); break;
            case 'D': printf("1101 "); break;
            case 'E': printf("1110 "); break;
            case 'F': printf("1111 "); break;
        }
        i++;
    }
    printf("\n");
}

int main() {
    char hex[100];
    printf("Entrer un nombre hexadécimal: ");
    scanf("%s", hex);
    hexToBinary(hex);
    return 0;
}

Ce programme vérifie chaque caractère pour s’assurer qu’il est bien un caractère hexadécimal valide avant de procéder à la conversion. Il affiche un message d’erreur si un caractère invalide est détecté.

En pratiquant ces cas particuliers et en prenant en compte les pièges potentiels, vous serez mieux préparé à gérer les complexités de la conversion des nombres hexadécimaux en binaire en langage C.