strtod, _strtod_l, wcstod, _wcstod_l

  • Article

Convertissent les chaînes en valeur double précision.

Syntaxe

double strtod(
   const char *strSource,
   char **endptr
);
double _strtod_l(
   const char *strSource,
   char **endptr,
   _locale_t locale
);
double wcstod(
   const wchar_t *strSource,
   wchar_t **endptr
);
double _wcstod_l(
   const wchar_t *strSource,
   wchar_t **endptr,
   _locale_t locale
);

Paramètres

strSource
Chaîne se terminant par un caractère Null à convertir.

endptr
Pointeur désignant le caractère qui arrête l’analyse.

locale
Paramètres régionaux à utiliser.

Valeur retournée

strtod retourne la valeur du nombre à virgule flottante, sauf lorsque la représentation provoque un dépassement de capacité, auquel cas la fonction retourne +/-HUGE_VAL. Le signe HUGE_VAL correspond au signe de la valeur qui ne peut pas être représentée. strtod retourne 0 si aucune conversion ne peut être effectuée ou qu’un sous-flux se produit.

wcstod retourne des valeurs analogues à strtod:

  • Pour les deux fonctions, errno prend la valeur ERANGE si un dépassement de capacité positif ou négatif se produit.
  • S’il existe des paramètres non valides, errno est défini EINVAL sur et le gestionnaire de paramètres non valide est appelé, comme décrit dans la validation des paramètres.

Pour plus d’informations sur ce code et d’autres codes de retour, consultez , , _sys_errlist_doserrnoet _sys_nerr.errno

Notes

Chaque fonction convertit la chaîne d’entrée strSource en double. La fonction strtod convertit strSource en valeur double précision. strtod arrête la lecture de la chaîne strSource au premier caractère qu’elle ne peut pas reconnaître dans le cadre d’un nombre. Ce caractère peut être le caractère null de fin. wcstod est une version à caractères larges de strtod ; son argument strSource est une chaîne de caractères larges. Ces fonctions se comportent sinon de façon identique.

Par défaut, l’état global de cette fonction est limité à l’application. Pour modifier ce comportement, consultez État global dans le CRT.

Mappages de routine de texte générique

TCHAR.H Routine _UNICODE et _MBCS non défini _MBCS Défini _UNICODE Défini
_tcstod strtod strtod wcstod
_tcstod_l _strtod_l _strtod_l _wcstod_l

Le LC_NUMERIC paramètre de catégorie des paramètres régionaux actuels détermine la reconnaissance du caractère de point radix dans strSource. Pour plus d’informations, consultez setlocale. Les fonctions sans _l suffixe utilisent les paramètres régionaux actuels ; _strtod_l elles sont identiques à _strtod celles utilisées par l’ancien locale . Pour plus d’informations, consultez Locale.

Si endptr ce n’est pas NULLle cas, un pointeur vers le caractère qui a arrêté l’analyse est stocké à l’emplacement vers lequel pointe endptr. Si aucune conversion ne peut être effectuée (aucun chiffre valide n’a été trouvé ou la base spécifiée n’est pas valide), la valeur de strSource est stockée à l’emplacement désigné par endptr.

strtodstrSource s’attend à pointer vers une chaîne de l’une des formes suivantes :

[whitespace] [sign] {digits [radixdigits] | radixdigits} [{e | E} [sign] digits]
[whitespace] [sign] {0x | 0X} {hexdigits [radixhexdigits] | radixhexdigits} [{p | P} [sign] digits]
[whitespace] [sign] {INF | INFINITY}
[whitespace] [sign] NAN [sequence]

Le début whitespace facultatif peut être constitué d’espaces et de caractères de tabulation, qui sont ignorés.
sign est plus (+) ou moins (-).
digits sont un ou plusieurs chiffres décimaux.
hexdigits sont un ou plusieurs chiffres hexadécimaux.
radix est le caractère de point radix, soit un point (.) dans les paramètres régionaux « C » par défaut, soit la valeur spécifique aux paramètres régionaux si les paramètres régionaux actuels sont différents ou lorsqu’ils locale sont spécifiés.
A sequence est une séquence de caractères alphanumériques ou de trait de soulignement.

Dans les formes nombre décimales et hexadécimales, si aucun chiffre n’apparaît avant le caractère de point radix, au moins un doit apparaître après le caractère de point radix.

Sous la forme décimale, les chiffres décimaux peuvent être suivis d’un exposant, qui se compose d’une lettre d’introduction (e ou E) et d’un entier signé éventuellement.

Sous la forme hexadécimale, les chiffres hexadécimaux peuvent être suivis d’un exposant, qui se compose d’une lettre d’introduction (p ou P) et d’un entier décimal signé facultatif qui représente l’exposant sous la forme d’une puissance de 2.

Dans l’un ou l’autre formulaire, s’il n’existe pas de partie exposant ou de point radix, un caractère de point radix est supposé suivre le dernier chiffre de la chaîne.

Le cas est ignoré à la fois dans les formulaires et NAN dans les INF formulaires. Le premier caractère qui ne correspond pas à l’une de ces formes arrête l’analyse.

Les versions UCRT de ces fonctions ne prennent pas en charge la conversion de lettres exposantes (d ou D) de style Fortran. Cette extension non standard était prise en charge par les versions antérieures de la bibliothèque CRT et peut être une modification avec rupture pour votre code. Les versions UCRT prennent en charge les chaînes hexadécimales et l’aller-retour des INFNAN valeurs, qui n’ont pas été prises en charge dans les versions antérieures. Cette prise en charge peut également entraîner des changements cassants dans votre code. Par exemple, la chaîne «0x1a » serait interprétée par strtod 0.0 dans les versions précédentes, mais comme 26.0 dans la version UCRT.

Spécifications

Routine En-tête requis
strtod, _strtod_l C : <stdlib.h> C++ : <cstdlib> ou <stdlib.h>
wcstod, _wcstod_l C : <stdlib.h> ou <wchar.h> C++ : <cstdlib>, <stdlib.h>ou <wchar.h>

Pour plus d’informations sur la compatibilité, consultez Compatibility.

Exemple

// crt_strtod.c
// This program uses strtod to convert a
// string to a double-precision value; strtol to
// convert a string to long integer values; and strtoul
// to convert a string to unsigned long-integer values.
//

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

int main(void)
{
    char *string, *stopstring;
    double x;
    long   l;
    int    base;
    unsigned long ul;

    string = "3.1415926This stopped it";
    x = strtod(string, &stopstring);
    printf("string = %s\n", string);
    printf("   strtod = %f\n", x);
    printf("   Stopped scan at: %s\n\n", stopstring);

    string = "-10110134932This stopped it";
    l = strtol(string, &stopstring, 10);
    printf("string = %s\n", string);
    printf("   strtol = %ld\n", l);
    printf("   Stopped scan at: %s\n\n", stopstring);

    string = "10110134932";
    printf("string = %s\n", string);

    // Convert string using base 2, 4, and 8:
    for (base = 2; base <= 8; base *= 2)
    {
        // Convert the string:
        ul = strtoul(string, &stopstring, base);
        printf("   strtol = %ld (base %d)\n", ul, base);
        printf("   Stopped scan at: %s\n", stopstring);
    }

    // NaN
    x = strtod("+nan", &stopstring);
    printf("\n%f\n", x);

    // INF
    x = strtod("-INF", &stopstring);
    printf("\n%f\n", x);

    // e - exponent
    x = strtod("1.18973e+49", &stopstring);
    printf("\n%f\n", x);

    // doesn't handle Fortran style
    x = strtod("1.18973d+49", &stopstring);
    printf("\n%f\n", x);
    printf("No Fortran style support. Stopped parsing at %s\n", stopstring);
}

string = 3.1415926This stopped it
   strtod = 3.141593
   Stopped scan at: This stopped it

string = -10110134932This stopped it
   strtol = -2147483648
   Stopped scan at: This stopped it

string = 10110134932
   strtol = 45 (base 2)
   Stopped scan at: 34932
   strtol = 4423 (base 4)
   Stopped scan at: 4932
   strtol = 2134108 (base 8)
   Stopped scan at: 932

nan

-inf

11897299999999999421285862642874618947301378359296.000000

1.189730
No Fortran style support. Stopped parsing at d+49

Voir aussi

Conversion de données
Prise en charge mathématique et à virgule flottante
Interprétation des séquences de caractères multioctets
Paramètres régionaux
Chaîne à fonctions de valeur numérique
strtol, wcstol, _strtol_l, _wcstol_l
strtoul, _strtoul_l, wcstoul, _wcstoul_l
atof, _atof_l, _wtof, _wtof_l
localeconv
_create_locale, _wcreate_locale
_free_locale