strtod, _strtod_l, wcstod, _wcstod_l

Converte cadeias de caracteres em um valor de precisão dupla.

Sintaxe

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

Parâmetros

strSource
Cadeia de caracteres terminada em nulo a ser convertida.

endptr
Ponteiro para o caractere que interrompe a verificação.

locale
A localidade a ser usada.

Valor retornado

strtod retorna o valor do número de ponto flutuante, exceto quando a representação causaria um estouro. Nesse caso, a função retorna +/-HUGE_VAL. O sinal de HUGE_VAL coincide com o sinal do valor que não pode ser representado. strtod retornará 0 se nenhuma conversão puder ser realizada ou ocorrer um estouro negativo.

wcstod retorna valores de maneira semelhante a strtod:

• Para ambas as funções, errno será definido como ERANGE se ocorrer um estouro ou estouro negativo.
• Se houver parâmetros inválidos, errno será definido como EINVAL e o manipulador de parâmetro inválido será invocado, conforme descrito em Validação de parâmetro.

Para obter mais informações sobre esses e outros códigos de retorno, confira errno, _doserrno, _sys_errlist e _sys_nerr.

Comentários

Cada função converte a cadeia de caracteres de entrada strSource para um double. A função strtod converte strSource para um valor de precisão dupla. strtod interrompe a leitura da cadeia de caracteres strSource no primeiro caractere que ela não puder reconhecer como parte de um número. Este pode ser o caractere nulo de terminação. wcstod é uma versão de caractere largo de strtod; seu argumento strSource é uma cadeia de caracteres largos. Caso contrário, essas funções se comportam de forma idêntica.

Por padrão, o estado global dessa função tem como escopo o aplicativo. Para alterar esse comportamento, confira Estado global no CRT.

Mapeamentos de rotina de texto genérico

A configuração de categoria LC_NUMERIC da localidade atual determina o reconhecimento do caractere de ponto fracionário em strSource. Para obter mais informações, consulte setlocale. As funções sem o sufixo _l usam a localidade atual. _strtod_l é idêntico a _strtod, exceto que o primeiro usa o locale informado. Para obter mais informações, consulte Localidade.

Se endptr não for NULL, um ponteiro para o caractere que parou a verificação será armazenado no local apontado por endptr. Se nenhuma conversão pode ser executada (Nenhum dígito válido foi encontrado ou uma base inválida foi especificada), o valor de strSource é armazenado no local apontado pela endptr.

strtod espera que strSource aponte para uma cadeia de caracteres em um dos seguintes formatos:

[whitespace] [sign] {digits [radix digits] | radix digits} [{e | E} [sign] digits]
[whitespace] [sign] {0x0X | } {hexdigits [radix hexdigits] | } radix hexdigits [{p | P} [sign] digits]
[whitespace] [sign] {INF | INFINITY}
[whitespace] [sign] NAN [sequence]

O whitespace à esquerda opcional pode consistir em caracteres de espaço ou tabulação, que são ignorados.
sign é mais (+) ou menos (-).
digits é um ou mais dígitos decimais.
hexdigits é um ou mais dígitos hexadecimais.
radix é o caractere de ponto fracionário, um ponto (.) na localidade padrão "C" ou o valor específico da localidade se a localidade atual for diferente ou quando locale for especificado.
Um sequence é uma sequência de caracteres alfanuméricos ou sublinhados.

Nas formas de número decimal e hexadecimal, se nenhum dígito for exibido antes do caractere de ponto fracionário, pelo menos um deverá aparecer após o caractere de ponto fracionário.

Os dígitos decimais podem ser seguidos por um expoente, que consiste em uma letra de apresentação (e ou E) e, opcionalmente, um inteiro com sinal.

Os dígitos hexadecimais podem ser seguidos por um expoente, que consiste em uma letra de apresentação (p ou P) e, opcionalmente, um inteiro com sinal, que representa o expoente elevado a dois.

Em qualquer forma, se não houver uma parte expoente ou um caractere de ponto fracionário, um caractere de ponto fracionário será assumido para seguir o último dígito na cadeia de caracteres.

As maiúsculas e minúsculas são ignoradas nos formulários INF e NAN. O primeiro caractere que não se ajusta a um desses formulários interrompe a verificação.

As versões UCRT dessas funções não dão suporte para a conversão de letras de expoente do estilo Fortran (d ou D). Essa extensão não padrão tinha suporte em versões anteriores do CRT e pode ser uma alteração significativa para seu código. As versões UCRT dão suporte a cadeias de caracteres hexadecimais e ciclo completo dos valores INF e NAN, que não eram compatíveis com versões anteriores. Esse suporte também pode causar alterações significativas em seu código. Por exemplo, a cadeia de caracteres "0x1a" seria interpretada por strtod como 0.0 em versões anteriores, mas como 26.0 na versão UCRT.

Requisitos

Para obter informações sobre compatibilidade, consulte Compatibilidade.

Exemplo

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

Confira também

Conversão de dados
Suporte matemático e de ponto flutuante
Interpretação de sequências de caracteres multibyte
Localidade
String para funções de valor numérico
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