atof, _atof_l, _wtof, _wtof_l

Convertissent une chaîne en double.

Syntaxe

double atof(
   const char *str
);
double _atof_l(
   const char *str,
   _locale_t locale
);
double _wtof(
   const wchar_t *str
);
double _wtof_l(
   const wchar_t *str,
   _locale_t locale
);

Paramètres

str
Chaîne à convertir.

locale
Paramètres régionaux à utiliser.

Valeur retournée

Chaque fonction retourne la valeur double produite en interprétant les caractères d’entrée en tant que nombre. La valeur de retour est 0.0 si l’entrée ne peut pas être convertie en valeur de ce type.

Dans tous les cas hors limites, errno est défini sur ERANGE. Si le paramètre passé est NULL, le gestionnaire de paramètres non valide est appelé, comme décrit dans la validation des paramètres. Si l’exécution est autorisée à se poursuivre, ces fonctions définissent errno avec la valeur EINVAL et retournent 0.

Notes

Ces fonctions convertissent une chaîne de caractères en valeur à virgule flottante double précision.

La chaîne d’entrée est une séquence de caractères qui peut être interprétée comme une valeur numérique du type spécifié. La fonction cesse de lire la chaîne d’entrée 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 ('\0' ou L'\0') terminant la chaîne.

L’argument str de atof et _wtof prend la forme suivante :

[whitespace] [sign] [digits] [.digits] [ {e | E }[sign]digits]

Un whitespace espace ou des caractères de tabulation, qui sont ignorés ; sign est plus (+) ou moins (-) et digits est un ou plusieurs chiffres décimaux. Si aucun chiffre n’apparaît avant la virgule décimale, au moins un doit apparaître après celle-ci. Les chiffres décimaux peuvent être suivis d’un exposant, qui se compose d’une lettre d’introduction (e ou E) et, éventuellement, d’un entier décimal signé.

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 de ces fonctions avec le _l suffixe sont identiques, sauf qu’elles utilisent le locale paramètre passé au lieu des paramètres régionaux actuels.

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
_tstof	atof	atof	_wtof
_ttof	atof	atof	_wtof

Spécifications

Routine(s)	En-tête requis
atof, _atof_l	C : <math.h> ou <stdlib.h> C++ : <cstdlib>, <stdlib.h>ou <cmath><math.h>
_wtof, _wtof_l	C : <stdlib.h> ou <wchar.h> C++ : <cstdlib>, <stdlib.h> ou <wchar.h>

Exemple

Ce programme montre comment les nombres stockés sous forme de chaînes peuvent être convertis en valeurs numériques à l’aide des fonctions atof et _atof_l.

// crt_atof.c
//
// This program shows how numbers stored as
// strings can be converted to numeric
// values using the atof and _atof_l functions.

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

int main(void)
{
    char    *str = NULL;
    double value = 0;
    _locale_t fr = _create_locale(LC_NUMERIC, "fr-FR");

    // An example of the atof function
    // using leading and training spaces.
    str = "  3336402735171707160320 ";
    value = atof(str);
    printf("Function: atof(\"%s\") = %e\n", str, value);

    // Another example of the atof function
    // using the 'E' exponential formatting keyword.
    str = "3.1412764583E210";
    value = atof(str);
    printf("Function: atof(\"%s\") = %e\n", str, value);

    // An example of the atof and _atof_l functions
    // using the 'e' exponential formatting keyword
    // and showing different decimal point interpretations.
    str = "  -2,309e-25";
    value = atof(str);
    printf("Function: atof(\"%s\") = %e\n", str, value);
    value = _atof_l(str, fr);
    printf("Function: _atof_l(\"%s\", fr)) = %e\n", str, value);
}

Function: atof("  3336402735171707160320 ") = 3.336403e+21
Function: atof("3.1412764583E210") = 3.141276e+210
Function: atof("  -2,309e-25") = -2.000000e+00
Function: _atof_l("  -2,309e-25", fr)) = -2.309000e-25

Voir aussi

Conversion de données
Prise en charge mathématique et à virgule flottante
Paramètres régionaux
_ecvt
_fcvt
_gcvt
setlocale, _wsetlocale
_atodbl, _atodbl_l, _atoldbl, _atoldbl_l, _atoflt, _atoflt_l