atof, _atof_l, _wtof, _wtof_latof, _atof_l, _wtof, _wtof_l

Convertire una stringa in double.Convert a string to double.

SintassiSyntax

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
);

ParametriParameters

strstr
Stringa da convertire.String to be converted.

localelocale
Impostazioni locali da usare.Locale to use.

Valore restituitoReturn Value

Ogni funzione restituisce il doppie valore prodotto interpretando i caratteri di input sotto forma di numero.Each function returns the double value produced by interpreting the input characters as a number. Il valore restituito è 0.0 se l'input non può essere convertito in un valore di tale tipo.The return value is 0.0 if the input cannot be converted to a value of that type.

In tutti i casi, out-of-range errno è impostata su ERANGE.In all out-of-range cases, errno is set to ERANGE. Se il parametro passato è NULL, viene richiamato il gestore di parametri non validi, come descritto in convalida dei parametri.If the parameter passed in is NULL, the invalid parameter handler is invoked, as described in Parameter Validation. Se l'esecuzione può continuare, queste funzioni impostano errno alla EINVAL e restituiscono 0.If execution is allowed to continue, these functions set errno to EINVAL and return 0.

NoteRemarks

Queste funzioni convertono una stringa di caratteri in un valore a virgola mobile a precisione doppia.These functions convert a character string to a double-precision, floating-point value.

La stringa di input è una sequenza di caratteri che può essere interpretata come valore numerico del tipo specificato.The input string is a sequence of characters that can be interpreted as a numerical value of the specified type. La funzione interrompe la lettura della stringa di input in corrispondenza del primo carattere che non riconosce come parte di un numero.The function stops reading the input string at the first character that it cannot recognize as part of a number. Questo carattere può essere il carattere null ('\0' o L'\0') che termina la stringa.This character may be the null character ('\0' or L'\0') terminating the string.

Il str argomento atof e wtof ha il formato seguente:The str argument to atof and _wtof has the following form:

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

Un whitespace è costituito da caratteri spazio o tabulazione, ovvero vengono ignorati; sign è un segno più (+) o meno (-); e cifre sono uno o più cifre decimali.A whitespace consists of space or tab characters, which are ignored; sign is either plus (+) or minus (-); and digits are one or more decimal digits. Se non viene visualizzata alcuna cifra prima del separatore decimale, è necessario che sia presente almeno una cifra dopo il separatore decimale.If no digits appear before the decimal point, at least one must appear after the decimal point. Le cifre decimali possono essere seguite da un esponente che è costituito da una lettera di presentazione (espulsione, o E) e un numero intero decimale con segno facoltativo.The decimal digits may be followed by an exponent, which consists of an introductory letter (e, or E) and an optionally signed decimal integer.

Le versioni della libreria UCRT di queste funzioni non supportano la conversione dello stile di Fortran (d o D) lettere esponente.The UCRT versions of these functions do not support conversion of Fortran-style (d or D) exponent letters. Questa estensione non standard è supportata dalle versioni precedenti della libreria CRT e può rappresentare una modifica con impatto significativo per il codice esistente.This non-standard extension was supported by earlier versions of the CRT, and may be a breaking change for your code.

Le versioni di queste funzioni con il l suffisso sono identiche ad eccezione del fatto che usano il delle impostazioni locali parametro passato al posto di quelle correnti.The versions of these functions with the _l suffix are identical except that they use the locale parameter passed in instead of the current locale.

Mapping di routine di testo genericoGeneric-Text Routine Mappings

Routine TCHAR.HTCHAR.H routine _UNICODE e _MBCS non definiti_UNICODE & _MBCS not defined _MBCS definito_MBCS defined _UNICODE definito_UNICODE defined
tstof_tstof atofatof atofatof _wtof_wtof
ttof_ttof atofatof atofatof _wtof_wtof

RequisitiRequirements

RoutineRoutine(s) Intestazione obbligatoriaRequired header
atof, atof_latof, _atof_l C: <math.h> o <stdlib.h> C++: <cstdlib>, <stdlib.h>, <cmath> o <math.h>C: <math.h> or <stdlib.h> C++: <cstdlib>, <stdlib.h>, <cmath> or <math.h>
wtof, wtof_l_wtof, _wtof_l C: <stdlib.h> o <wchar.h> C++: <cstdlib>, <stdlib.h> o <wchar.h>C: <stdlib.h> or <wchar.h> C++: <cstdlib>, <stdlib.h> or <wchar.h>

EsempioExample

Questo programma viene illustrato come i numeri memorizzati come stringhe possono essere convertiti in valori numerici usando la atof e atof_l funzioni.This program shows how numbers stored as strings can be converted to numeric values using the atof and _atof_l functions.

// 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

Vedere ancheSee also

Conversione dei datiData Conversion
Supporto delle funzioni a virgola mobileFloating-Point Support
Impostazioni localiLocale
_ecvt_ecvt
_fcvt_fcvt
_gcvt_gcvt
setlocale, _wsetlocalesetlocale, _wsetlocale
_atodbl, _atodbl_l, _atoldbl, _atoldbl_l, _atoflt, _atoflt_l_atodbl, _atodbl_l, _atoldbl, _atoldbl_l, _atoflt, _atoflt_l