Chaîne vers int en C : atoi, strtol et la conversion de nombres en texte

Le texte arrive des utilisateurs, des fichiers et de la ligne de commande sous forme de caractères. "42" fait trois octets - '4', '2', '\0' - et rien dedans n'est le nombre 42 tant que vous ne l'avez pas converti. Le C offre deux générations de fonctions de conversion : les anciennes, courtes, qui ne peuvent pas signaler d'erreur, et les plus longues, qui le peuvent. Cette page montre les deux et explique pourquoi les vrais programmes utilisent la seconde.

L'ancienne famille : atoi, atol, atof

Elles se lisent comme leurs noms : ASCII vers int, vers long, vers double. Un argument, un résultat.

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

int main(void) {
    printf("%d\n", atoi("42"));
    printf("%d\n", atoi("  -17 residu qui traine"));
    printf("%f\n", atof("3.14"));
    return 0;
}

Les espaces initiaux sont sautés, un signe facultatif est lu, les chiffres sont consommés, et tout ce qui suit est ignoré. C'est pratique jusqu'à ce que l'entrée soit erronée :

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

int main(void) {
    printf("atoi(\"0\")       = %d\n", atoi("0"));
    printf("atoi(\"bonjour\") = %d\n", atoi("bonjour"));
    printf("atoi(\"\")        = %d\n", atoi(""));
    return 0;
}

Les trois affichent 0. Il n'y a aucun code de retour, aucun drapeau, aucun moyen de demander « est-ce que cela a marché ? » - et une valeur qui déborde un int est un comportement indéfini plutôt qu'une erreur signalée. Pour un littéral écrit en dur dans un programme jouet, c'est tolérable. Pour tout ce qu'une personne ou un fichier peut fournir, c'est un générateur de bugs silencieux.

Le bon outil : strtol

strtol (string to long) est la même conversion avec deux canaux pour rapporter ce qui s'est passé.

long strtol(const char *text, char **endptr, int base);

endptr est positionné sur le premier caractère que la fonction n'a pas consommé. base est la base numérique - utilisez 10, ou 0 pour laisser le préfixe du littéral décider (0x pour l'hexadécimal, un zéro initial pour l'octal).

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

int main(void) {
    const char *input = "42 pommes";
    char *end;

    long value = strtol(input, &end, 10);

    printf("valeur = %ld\n", value);
    printf("arrete a : \"%s\"\n", end);
    printf("%td caracteres consommes\n", end - input);
    return 0;
}

Lire endptr répond aux questions qu'atoi ne peut pas :

• end == input signifie que rien n'a été converti - le texte ne commençait pas par un nombre.
• *end != '\0' signifie qu'il restait du contenu. Que ce soit une erreur, c'est votre décision : c'est acceptable en analysant "42 pommes", et problématique quand toute la ligne aurait dû être un nombre.

Le débordement est signalé séparément via errno. L'idiome complet et correct mérite d'être écrit une fois puis réutilisé :

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

/* renvoie 1 en cas de succes, 0 pour tout type d'echec */
int parse_int(const char *text, int *out) {
    char *end;
    errno = 0;

    long value = strtol(text, &end, 10);

    if (end == text) {
        return 0;                 /* aucun chiffre */
    }
    if (*end != '\0') {
        return 0;                 /* residu */
    }
    if (errno == ERANGE || value < INT_MIN || value > INT_MAX) {
        return 0;                 /* hors de la plage d'un int */
    }

    *out = (int)value;
    return 1;
}

int main(void) {
    const char *tests[] = {"42", "-7", "bonjour", "", "9999999999", "12abc"};
    int n = (int)(sizeof tests / sizeof tests[0]);

    for (int i = 0; i < n; i++) {
        int value;
        if (parse_int(tests[i], &value)) {
            printf("\"%s\" -> %d\n", tests[i], value);
        } else {
            printf("\"%s\" -> rejete\n", tests[i]);
        }
    }
    return 0;
}

Trois détails rendent cela correct. errno = 0 avant l'appel compte parce que la bibliothèque ne fait que positionner errno ; elle ne l'efface jamais, donc une valeur périmée d'un appel antérieur serait lue comme l'échec de celui-ci. strtol renvoie un long, qui peut être plus large qu'un int, donc le contrôle de plage contre INT_MIN/INT_MAX est distinct d'ERANGE. Et renvoyer le succès comme état tout en livrant la valeur via un pointeur est la façon dont les fonctions C rapportent « soit une valeur, soit un échec » - la valeur de retour ne peut pas faire les deux travaux.

strtoul est l'équivalent non signé, et strtoll/strtoull gèrent long long.

Les autres bases

La base 16 lit l'hexadécimal ; la base 0 inspecte le préfixe et décide elle-même.

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

int main(void) {
    char *end;

    printf("%ld\n", strtol("ff", &end, 16));      /* 255 */
    printf("%ld\n", strtol("0x1A", &end, 0));     /* 26, prefixe detecte */
    printf("%ld\n", strtol("1011", &end, 2));     /* 11, binaire */
    printf("%ld\n", strtol("755", &end, 8));      /* 493, octal */
    return 0;
}

La base 0 est un piège dans un cas précis : un décimal complété par des zéros comme "012" est lu en octal et sort à 10. Si votre entrée est décimale, dites 10 explicitement.

La virgule flottante : strtod

strtod a la même forme pour double, et atof a le même défaut qu'atoi.

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

int main(void) {
    const char *text = "3.14159 reste";
    char *end;
    errno = 0;

    double value = strtod(text, &end);

    if (end == text) {
        printf("pas un nombre\n");
    } else if (errno == ERANGE) {
        printf("hors plage\n");
    } else {
        printf("valeur = %f, arrete a \"%s\"\n", value, end);
    }
    return 0;
}

strtod accepte aussi la notation scientifique ("1.5e3"), les flottants hexadécimaux, et les mots "inf" et "nan". La locale affecte le séparateur décimal, ce qui surprend les gens analysant des fichiers écrits ailleurs - dans la locale « C » par défaut, le séparateur est toujours un point.

Des nombres vers le texte : snprintf

Dans l'autre sens, snprintf est la réponse standard. Il écrit au plus la taille que vous lui donnez, termine toujours la chaîne, et renvoie la longueur dont le résultat complet aurait eu besoin.

#include <stdio.h>

int main(void) {
    char buf[32];
    int n = 4095;

    int written = snprintf(buf, sizeof buf, "%d", n);
    printf("texte : \"%s\" (%d caracteres necessaires)\n", buf, written);

    snprintf(buf, sizeof buf, "%05d", n);
    printf("complete : %s\n", buf);

    snprintf(buf, sizeof buf, "%x / %o / %.2f", n, n, n / 1000.0);
    printf("mixte :   %s\n", buf);
    return 0;
}

La valeur de retour est le test de troncature. Si elle est supérieure ou égale à la taille du tampon, le texte n'a pas tenu :

#include <stdio.h>

int main(void) {
    char small[8];

    int needed = snprintf(small, sizeof small, "valeur=%d", 1234567);

    if (needed < 0) {
        printf("erreur d'encodage\n");
    } else if ((size_t)needed >= sizeof small) {
        printf("tronque : \"%s\" (%d octets necessaires)\n", small, needed + 1);
    } else {
        printf("ok : %s\n", small);
    }
    return 0;
}

Deux choses à ne pas prendre : itoa ne fait pas partie du C standard, donc du code l'utilisant ne compilera pas partout ; et sprintf est snprintf sans la limite de taille, ce qui signifie qu'il écrira au-delà de la fin de votre tampon sans broncher.

Les caractères isolés et '0'

Les caractères '0' à '9' sont garantis consécutifs, une simple soustraction convertit donc entre un caractère de chiffre et sa valeur.

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

int main(void) {
    char c = '7';
    int digit = c - '0';
    printf("char '%c' -> int %d\n", c, digit);

    int value = 3;
    char back = (char)(value + '0');
    printf("int %d -> char '%c'\n", value, back);
    return 0;
}

Seuls les chiffres se comportent ainsi - les lettres ne sont pas tenues d'être consécutives, donc c - 'a' n'est pas portable pour l'arithmétique alphabétique. Protégez la soustraction avec isdigit avant de lui faire confiance :

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

int main(void) {
    char text[] = "a1b2c3";
    int sum = 0;

    for (int i = 0; text[i] != '\0'; i++) {
        if (isdigit((unsigned char)text[i])) {
            sum += text[i] - '0';
        }
    }

    printf("la somme des chiffres vaut %d\n", sum);
    return 0;
}

Le cast en unsigned char est requis pour la même raison que dans les chaînes : les fonctions de <ctype.h> sont indéfinies pour des arguments négatifs, et un char simple peut être signé.

Quelle fonction utiliser

• Texte venant d'un utilisateur, d'un fichier ou d'argv → strtol / strtod avec la vérification complète.
• Un littéral que vous avez écrit et contrôlez → atoi est acceptable, quoique sans intérêt.
• Un nombre vers un tampon → snprintf, et vérifiez la valeur de retour.
• Un caractère de chiffre → soustrayez '0', après isdigit.
• Jamais → gets, sprintf, itoa.