atof, _atof_l, _wtof, _wtof_l

Convertire una stringa in double.

Sintassi

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

Parametri

str
Stringa da convertire.

locale
Impostazioni locali da usare.

Valore restituito

Ogni funzione restituisce il valore double che viene prodotto interpretando i caratteri di input come numero. Il valore restituito è 0,0 se l'input non può essere convertito in un valore di tale tipo.

In tutti i casi fuori intervallo, errno è impostato su ERANGE. Se il parametro passato è NULL, viene richiamato il gestore di parametri non validi, come descritto in Convalida dei parametri. Se l'esecuzione può continuare, queste funzioni impostano errno su EINVAL e restituiscono 0.

Osservazioni:

Queste funzioni convertono una stringa di caratteri in un valore a virgola mobile a precisione doppia.

La stringa di input è una sequenza di caratteri che può essere interpretata come valore numerico del tipo specificato. La funzione interrompe la lettura della stringa di input al primo carattere che non è in grado di riconoscere come parte di un numero. Questo carattere può essere il carattere null ('\0' o L'\0') che termina la stringa.

L'argomento str per atof e _wtof ha il formato seguente:

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

Un whitespace oggetto è costituito da spazi o caratteri di tabulazione, che vengono ignorati; sign è più (+) o meno (-) e digits sono una o più cifre decimali. Se non viene visualizzata alcuna cifra prima del separatore decimale, è necessario che sia presente almeno una cifra dopo il separatore decimale. Le cifre decimali possono essere seguite da un esponente, costituito da una lettera introduttiva (e o E) e un intero decimale con segno facoltativo.

Le versioni UCRT di queste funzioni non supportano la conversione di lettere esponenti di tipo Fortran (d o D). Questa estensione non standard è supportata dalle versioni precedenti della libreria CRT e può rappresentare una modifica con impatto significativo per il codice esistente.

Le versioni di queste funzioni con il _l suffisso sono identiche, ad eccezione del fatto che usano il locale parametro passato anziché le impostazioni locali correnti.

Per impostazione predefinita, lo stato globale di questa funzione è limitato all'applicazione. Per modificare questo comportamento, vedere Stato globale in CRT.

Mapping di routine di testo generico

TCHAR.H Routine	_UNICODE e _MBCS non definito	_MBCS Definito	_UNICODE Definito
_tstof	atof	atof	_wtof
_ttof	atof	atof	_wtof

Requisiti

Routine	Intestazione obbligatoria
atof, _atof_l	C: <math.h> o <stdlib.h> C++: <cstdlib>, <stdlib.h>o <cmath><math.h>
_wtof, _wtof_l	C: <stdlib.h> o <wchar.h> C++: <cstdlib>, <stdlib.h> o <wchar.h>

Esempio

Questo programma mostra come i numeri memorizzati come stringhe possono essere convertiti in valori numerici usando le funzioni atof e _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

Vedi anche

Conversione dei dati
Supporto matematico e a virgola mobile
impostazioni locali
_ecvt
_fcvt
_gcvt
setlocale, _wsetlocale
_atodbl, _atodbl_l, _atoldbl, _atoldbl_l, _atoflt, _atoflt_l