Salut tout le monde !

Débutant en C, j'ai récemment développé un programme qui affiche des nombres en base 16 pour prendre en main le langage. Le résultat fonctionne correctement, cependant je suis un petit peu frustré par les lignes 16 et 17... J'aurais aimé que la fonction qui change le nombre de base puisse retourner la chaîne de caractère directement plutôt que de devoir la définir plus haut en faisant appel à plusieurs instructions compliquées comme des malloc, etc..., puis la fonction l.16 et pour finir un free...

Du coup ma question est : aurais-t-il été possible d'intégrer toutes ces étapes dans ma fonction principale (nbtohex) de façon à n'écrire qu'une seule ligne de code dans le main ?

#include <stdio.h>
#include <stdlib.h>

void nbtohex(int nb, char* output);
char inttohex(int nb);

int main(int argc, const char * argv[])
{
    char *output = NULL;
    output = malloc(sizeof(char) * 100);
    if (output == NULL)
    {
        exit(0);
    }
    
    nbtohex(9082, output);
    printf("%s\n", output);
    
    free(output);
    
    return 0;
}

void nbtohex(int nb, char* output)
{
    int compteur = 0, tab[100] = {0};
    output[0] = '0';
    output[1] = 'x';

    do
    {
        tab[compteur] = inttohex(nb % 16);
        nb /= 16;
        compteur++;
    } while (nb > 0);
    
    int i;
    for (i = 2; i < compteur + 2; i++) {
        output[i] = tab[compteur - i + 1];
    }
}

char inttohex(int nb)
{
    switch (nb)
    {
        case 0:
            nb = '0';
            break;
        case 1:
            nb = '1';
            break;
        case 2:
            nb = '2';
            break;
        case 3:
            nb = '3';
            break;
        case 4:
            nb = '4';
            break;
        case 5:
            nb = '5';
            break;
        case 6:
            nb = '6';
            break;
        case 7:
            nb = '7';
            break;
        case 8:
            nb = '8';
            break;
        case 9:
            nb = '9';
            break;
        case 10:
            nb = 'A';
            break;
        case 11:
            nb = 'B';
            break;
        case 12:
            nb = 'C';
            break;
        case 13:
            nb = 'D';
            break;
        case 14:
            nb = 'E';
            break;
        case 15:
            nb = 'F';
            break;
    }
    return nb;
}

Hello,

Bin oui: 

int main(int argc, const char * argv[])
{
    char output[100]={0};
     
    printf("%s\n",nbtohex(9082, output));
     
    return 0;
}
 
char *nbtohex(int nb,char *output)
{
    ....
	
	return(output);
}
 

Mais alors, ton switch() 

Sans tester si la valeur de nb est valide (ce que tu ne fais pas non plus), ta fonction se résume à 

char inttohex(int nb)
{
    if(nb<=9)
		return('0'+nb);

	return('A'+nb-10);
}

-
Edité par edgarjacobs 15 octobre 2019 à 20:40:17

Salut ! Apparemment tu te limites à 100 chiffres, c'est bien ça ? Dans ce cas, je suis d'accord qu'il faudrait se passer d'allocation dynamique : tu n'as qu'à utiliser des chaînes de caractères de taille 100 (ou 101).

Remarque : tu peux simplifier la conversion d'un nombre entre 0 et 15 en chiffre hexadécimal, par exemple en faisant ce genre de chose :

char inttohex(int nb)
{
    char chiffre[] = "0123456789ABCDEF";
    return chiffre[nb] ;
}

egdarjacobs et robun : omgggggg je suis vraiment un noob  Merci ! Vous avez trouvé des solutions tellement plus simples que ce que j'ai fait au départ !

@robun: on peut même se passer de la variable chiffre[ ] (et c'est certainement ce que fait le compilateur) -- je n'ai pas écrit que c'était plus lisible

char inttohex(int nb) {
    return("0123456789abcdef"[nb]);
}	

-
Edité par edgarjacobs 15 octobre 2019 à 21:41:52

Drôle d'écriture, mais tout à fait logique !