strtod, _strtod_l, wcstod, _wcstod_l

Converte una stringa di caratteri in un valore a precisione doppia.

Sintassi

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

Parametri

strSource
Stringa con terminazione Null da convertire.

endptr
Puntatore al carattere che interrompe la lettura.

locale
Impostazioni locali da usare.

Valore restituito

strtod restituisce il valore del numero a virgola mobile, tranne quando la rappresentazione provocherebbe un overflow, nel qual caso la funzione restituisce +/-HUGE_VAL. Il segno di HUGE_VAL corrisponde al segno del valore che non può essere rappresentato. strtod restituisce 0 se non è possibile eseguire alcuna conversione o se si verifica un underflow.

wcstod restituisce valori in modo analogo a strtod:

• Per entrambe le funzioni, errno viene impostato su ERANGE in caso di overflow o underflow.
• Se sono presenti parametri non validi, errno viene impostato su EINVAL e viene richiamato il gestore di parametri non validi, come descritto in Convalida dei parametri.

Per altre informazioni su questo e altri codici restituiti, vedere errno, _doserrno, _sys_errliste _sys_nerr.

Osservazioni:

Ogni funzione converte la stringa di input strSource in un valore double. La funzione strtod converte strSource in un valore a precisione doppia. strtod interrompe la lettura della stringa strSource al primo carattere che non è in grado di riconoscere come parte di un numero. Questo carattere può essere il carattere Null di terminazione. wcstod è una versione a caratteri wide di strtod. L'argomento strSource è una stringa di caratteri wide. A parte ciò, queste funzioni si comportano in modo identico.

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
_tcstod	strtod	strtod	wcstod
_tcstod_l	_strtod_l	_strtod_l	_wcstod_l

L'impostazione LC_NUMERIC della categoria delle impostazioni locali correnti determina il riconoscimento del carattere punto di radix in strSource. Per ulteriori informazioni, vedere setlocale. Le funzioni senza il _l suffisso usano le impostazioni locali correnti. _strtod_l È identico a _strtod tranne il precedente usa invece l'oggetto locale passato. Per altre informazioni, vedere Locale.

Se endptr non NULLè , un puntatore al carattere che ha arrestato l'analisi viene archiviato nella posizione a endptrcui punta . Se è non possibile eseguire alcuna conversione (non vengono trovate cifre valide o viene specificata una base non valida), il valore di strSource viene archiviato in corrispondenza della posizione a cui punta endptr.

strtod prevede di strSource puntare a una stringa di uno dei formati seguenti:

[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]

Il carattere iniziale whitespace facoltativo può essere costituito da spazi e caratteri di tabulazione, che vengono ignorati.
sign è più (+) o meno (-).
digits sono una o più cifre decimali.
hexdigits sono una o più cifre esadecimali.
radix è il carattere punto radix, un punto (.) nelle impostazioni locali predefinite "C" o il valore specifico delle impostazioni locali se le impostazioni locali correnti sono diverse o quando locale viene specificato.
Un sequence è una sequenza di caratteri alfanumerici o di caratteri di sottolineatura.

In entrambi i formati numerici decimali ed esadecimali, se non vengono visualizzate cifre prima del carattere punto di radix, almeno uno deve essere visualizzato dopo il carattere del punto di radix.

Nel formato decimale, le cifre decimali possono essere seguite da un esponente, costituito da una lettera introduttiva (e o E) e da un intero con segno facoltativo.

Nel formato esadecimale, le cifre esadecimali possono essere seguite da un esponente, costituito da una lettera introduttiva (p o P) e da un numero intero decimale facoltativamente con segno che rappresenta l'esponente come potenza di 2.

In entrambi i moduli, se non è presente una parte esponente o un carattere di punto radix, si presuppone che un carattere di punto radix segua l'ultima cifra nella stringa.

La distinzione tra maiuscole e e NAN minuscole viene ignorata.INF Il primo carattere che non rientra in una di queste forme interrompe l'analisi.

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 UCRT supportano stringhe esadecimali e round trip di INF valori e NAN , che non erano supportati nelle versioni precedenti. Questo supporto può anche causare modifiche di rilievo nel codice. Ad esempio, la stringa "0x1a" verrebbe interpretata da strtod come 0.0 nelle versioni precedenti, ma come 26.0 nella versione UCRT.

Requisiti

Ciclo	Intestazione obbligatoria
strtod, _strtod_l	C: <stdlib.h> C++: <cstdlib> o <stdlib.h>
wcstod, _wcstod_l	C: <stdlib.h> o <wchar.h> C++: <cstdlib>, <stdlib.h>o <wchar.h>

Per altre informazioni sulla compatibilità, vedere Compatibility (Compatibilità).

Esempio

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

Vedi anche

Conversione dei dati
Supporto matematico e a virgola mobile
Interpretazione di sequenze di caratteri multibyte
impostazioni locali
Funzioni string to numeric value (Da stringa a valore numerico)
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