Compartir a través de

strtod, _strtod_l, , wcstod, _wcstod_l

  • Artículo

Convierte las cadenas en un valor de precisión doble.

Sintaxis

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
Cadena terminada en NULL que se va a convertir.

endptr
Puntero al carácter que detiene el examen.

locale
Configuración regional que se va a usar.

Valor devuelto

strtod devuelve el valor del número de punto flotante, excepto si la representación fuera a producir un desbordamiento, en cuyo caso la función devuelve +/-HUGE_VAL. El signo de HUGE_VAL coincide con el signo del valor que no se puede representar. strtod devuelve 0 si no se puede efectuar ninguna conversión o si se produce un subdesbordamiento.

wcstod devuelve valores de manera parecida a strtod:

  • Para ambas funciones, errno se establece en ERANGE si se produce un desbordamiento o subdesbordamiento.
  • Si hay parámetros no válidos, errno se establece EINVAL en y se invoca el controlador de parámetros no válidos, como se describe en Validación de parámetros.

Para obtener más información al respecto y otros códigos de retorno, vea errno, _doserrno, _sys_errlist y _sys_nerr.

Comentarios

Cada función convierte la cadena de entrada strSource en un double. La función strtod convierte strSource en un valor de precisión doble. strtod deja de leer la cadena strSource en el primer carácter que no reconoce como parte de un número. Este puede ser el carácter nulo de terminación. wcstod es una versión con caracteres anchos de strtod; su argumento strSource es una cadena de caracteres anchos. Por lo demás, estas funciones se comportan exactamente igual.

De manera predeterminada, el estado global de esta función está limitado a la aplicación. Para cambiar este comportamiento, consulte Estado global en CRT.

Asignaciones de rutinas de texto genérico

Rutina TCHAR.H _UNICODE y _MBCS no definidos _MBCS definido _UNICODE definido
_tcstod strtod strtod wcstod
_tcstod_l _strtod_l _strtod_l _wcstod_l

El valor de la categoría LC_NUMERIC de la configuración regional actual determina el reconocimiento del carácter de punto de base de strSource. Para obtener más información, vea setlocale. Las funciones que no tienen el sufijo _l usan la configuración regional actual; _strtod_l es idéntico a _strtod, salvo que el primero usa el objeto locale que se pasa. Para obtener más información, vea Locale.

Si endptr no es NULL, se almacena un puntero al carácter que detuvo el análisis en la ubicación a la que señala endptr. Si no se puede realizar ninguna conversión (no se encontraron dígitos válidos o se especificó una base no válida), el valor de strSource se almacena en la ubicación a la que señala endptr.

strtod espera que strSource señale a una cadena con uno de los formatos siguientes:

[] [whitespace] {digits [radix digits] | radix digits}sign [{e | E} [sign] digits]
[] [sign] {0x | 0X} {hexdigits [radix hexdigits] | radix hexdigits}whitespace [{p | P} [sign] digits]
[] [whitespace] {INF | INFINITY}sign
[] [whitespacesign] [] NANsequence

El objeto whitespace inicial opcional puede estar formado por caracteres de espacio y tabulación, que se omiten.
sign es más (+) o menos (-).
digits es uno o más dígitos decimales.
hexdigits es uno o más dígitos hexadecimales.
radix es el carácter de punto de base, ya sea un punto (.) en la configuración regional "C" predeterminada o el valor específico de la configuración regional si la configuración regional actual es diferente o si se ha especificado locale.
sequence es una secuencia de caracteres alfanuméricos o de subrayado.

En los formatos de número decimal y hexadecimal, si no aparecen dígitos antes del carácter de punto de base, al menos uno debe aparecer después del carácter de punto de base.

En el formato decimal, los dígitos decimales pueden ir seguidos de un exponente, que consta de una letra inicial (e o E) y un entero con signo optativo.

En el formato hexadecimal, los dígitos hexadecimales pueden ir seguidos de un exponente, que consta de una letra inicial (p o P) y un entero decimal con signo opcional que representa el exponente como una potencia elevada a 2.

En cualquiera de estos formatos, si no hay una parte de exponente o un carácter de punto de base, se da por hecho el último dígito de la cadena va seguido de un carácter de punto de base.

En los formatos INF y NAN no se distingue entre mayúsculas y minúsculas. El primer carácter que no se ajuste a uno de estos formatos detiene el análisis.

Las versiones UCRT de estas funciones no admiten la conversión de letras como exponente de estilo Fortran (d o D). Esta extensión no estándar era compatible con versiones anteriores de CRT y puede que sea un cambio decisivo para el código. Las versiones UCRT admiten cadenas hexadecimales y recorridos de ida y vuelta de los valores INF y NAN, que no se admitían en versiones anteriores. Esta compatibilidad también puede provocar cambios importantes en el código. Por ejemplo, strtod interpretaría la cadena "0x1a" como 0.0 en las versiones anteriores, pero como 26.0 en la versión UCRT.

Requisitos

Routine Encabezado necesario
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>

Para obtener más información sobre compatibilidad, consulte Compatibilidad.

Ejemplo

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

Vea también

Conversión de datos
Compatibilidad con cálculos matemáticos y el punto flotante
Interpretación de secuencias de caracteres de varios bytes
Configuración regional
Funciones de cadena a 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