Afficher un nombre en base 10

Hello, ok je sais il y a la fonction itoa pour ça mais recoder la fonction itoa juste pour change le type de variable c'est pas top top alors existe t-il une façon de faire plus simplement, un simple cast suffirait si je veux afficher 45 en unsigned ? en int ? mais pour ces type comment faire ? long int, long unsigned ? dois-je recoder à chaque fois la fonction itoa ? Merci

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#define SIZE    11

static char *getnbr(int n, char *p)
{
    int a;

    n = (a = n >= 0) ? -n : n;
    p += SIZE - 1;
    while (n <= -10)
    {
        *p-- = ('0' - (n % 10));
        n /= 10;
    }
    *p = ('0' - (n % 10));
    *--p = '-';
    return (!a ? p : ++p);
}

char        *ft_itoa(int n)
{
    char        p[SIZE + 1];

    p[SIZE] = 0;
    return (ft_strdup(getnbr(n, p)));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#define SIZE    20

static char *getnbr(long int n, char *p)
{
    int a;

    n = (a = n >= 0) ? -n : n;
    p += SIZE - 1;
    while (n <= -10)
    {
        *p-- = '0' - n % 10;
        n /= 10;
    }
    *p = '0' - n % 10;
    *--p = '-';
    return (!a ? p : ++p);
}

char        *ft_l_itoa(long int n)
{
    char p[SIZE + 1];

    p[SIZE] = 0;
    return (ft_strdup(getnbr(n, p)));
}

Salut,

Si tu n'a pas de contraintes particulières, la fonction sprintf() fait très bien le boulot. Il faut juste faire gaffe à ne pas écrire au-delà du tableau fournit en argument.

1
2
3

char s[32] = { 0 };

sprintf(s, "%d", -18);

Sinon, tu peux prévoir une seule fonction itoa() qui prend en argument un long int, soit le type entier signé le plus grand en C89.

Salut,

D'accord avec sprintf

Bof Bof, et pour les unsigned long, char* itoa(long) ne marchera pas.

En effet, mais c'est là le lot du typage. C'est pareil pour sprintf(), il est nécessaire de lui préciser le bon format. Après, on peut s'amuser avec le préprocesseur, mais avec les risques qui vont avec et en oubliant pas que cela gonfle le poids de l'exécutable final.

Édit : nouvelle version.
Édit (2) : par ailleurs, bien faire attention que cette macrofonction modifie ses arguments.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <stdio.h>

#define SIZE (32)
#define GETNBR(n, dst) \
    do { \
        int signe = ((n) < 0) ? 1 : 0; \
        (dst) += SIZE; \
        *--(dst) = 0; \
        while ((n) != 0) { \
            if (signe) \
                *--(dst) = '0' - (n) % 10; \
            else \
                *--(dst) = (n) % 10 + '0'; \
            (n) /= 10; \
        } \
        if (signe) \
            *--(dst) = '-'; \
    } while (0)


int
main(void)
{
    char s[SIZE];
    char *p = s;
    int n = 342;
    long m = -342;

    GETNBR(n, p);
    puts(p);
    p = s;
    GETNBR(m, p);
    puts(p);
    return 0;
}

Waw la macro x) Merci de votre aide, mais au fait je suis à 42 et donc j'ai quelque contrainte, dont en 1er: interdit de faire appel au fonction que l'on a pas codées sauf s'ils le disent.. Sinon, j'en déduit qu'a part ces solutions ce n'est pas possible Tant pis je coderais la même fonction

Bonsoir,

Chez moi en tout cas (MinGW/GCC 4.x sous windows), il existe pléthore de variantes de itoa pour d'autres types: ltoa, lltoa, ultoa, i64toa… C'est les versions pour nombres flottants qui sont plus difficile à trouver.

Par contre, dans le lot, je me demande ce qui fait vraiment partie ou pas du standard. C'est toujours un peu flou… de ce côté-là, au moins, snprintf est toujours une valeur sûre.

De ce côté, c'est simple : aucune (ni C89, ni C99, ni C11).

Yep, mais seulement en C99.

D'accord mais du coup, si j'utilise la macro GETNBR est-ce un résultat fiable si j'utlise pour exemple les options: %d & %i, %ld, %u et long unsigned ?

Mmm… Je ne suis pas ta question. La macrofonction GETNBR() que j'ai donné en exemple attend un entier et une chaîne de taille SIZE où sera stocké le nombre sous forme d'une chaîne. Après l'avoir appelée, tu n'as plus besoin de chaînes de format puisque que tu as une chaîne de caractères.

Non ce que je veux dire c'est:

Dans mon école ils ont un programme pour vérifier si le programme donne bien ou non le bon résultat à chaque fois, il ne doit y avoir en aucun cas un bug ou autres, donc si je prend l'affichage de printf %d %i etc.. je sais que le nombre s'affichera correctement selon le format alors est-ce que la macrofonction est sure pour les formats: %d %i %ld %u et long unsigned ?

Merci

J'ai envie de dire : essaye et vérifie.
Mais, oui, elle doit fonctionner quel que soit le type entier de son premier argument. Pour le reste, je ne comprend pas le rapprochement avec les formats de printf().