atof, _atof_l, _wtof, _wtof_l

Converta uma cadeia de caracteres em duplo.

Sintaxe

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

Parâmetros

str
Cadeia de caracteres a ser convertida.

locale
Localidade a usar.

Retornar valor

Cada função retorna o valor double produzido interpretando os caracteres de entrada como um número. O valor de retorno será 0,0 se a entrada não puder ser convertida em um valor desse tipo.

Em todos os casos de fora do intervalo, errno é definido como ERANGE. Se o parâmetro passado for NULL, o manipulador de parâmetros inválido será chamado, conforme descrito em Validação de parâmetro. Se a execução tiver permissão para continuar, essas funções definirão errno como EINVAL e retornarão 0.

Comentários

Essas funções convertem uma cadeia de caracteres em um valor de ponto flutuante de precisão dupla.

A cadeia de caracteres de entrada é uma sequência de caracteres que pode ser interpretada como um valor numérico do tipo especificado. A função pára de ler a cadeia de caracteres de entrada no primeiro caractere que não pode reconhecer como parte de um número. Esse caractere pode ser o caractere nulo ('\0' ou L'\0') que encerra a cadeia de caracteres.

O argumento str para atof e _wtof tem a seguinte forma:

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

Um whitespace consiste em caracteres de espaço ou tabulação, que são ignorados; sign é um sinal de mais (+) ou menos (-); e digits é composto por um ou mais dígitos decimais. Se nenhum dígito aparecer antes do ponto decimal, pelo menos um deverá aparecer após o ponto decimal. Os dígitos decimais podem ser seguidos por um expoente, que consiste em uma carta de apresentação (e ou E) e um inteiro decimal opcionalmente com sinal.

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 dessas funções com o sufixo _l são idênticas, com a exceção de que usam o parâmetro locale passado em vez da localidade atual.

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

Mapeamentos de rotina de texto genérico

Rotina TCHAR.H	_UNICODE e _MBCS não definidos	_MBCS definido	_UNICODE definido
_tstof	atof	atof	_wtof
_ttof	atof	atof	_wtof

Requisitos

Rotina(s)	Cabeçalho necessário
atof, _atof_l	C: <math.h> ou <stdlib.h> C++: <cstdlib>, <stdlib.h>, <cmath> ou <math.h>
_wtof, _wtof_l	C: <stdlib.h> ou <wchar.h> C++: <cstdlib>, <stdlib.h> ou <wchar.h>

Exemplo

Esse programa mostra como os números armazenados como cadeias de caracteres podem ser convertidos em valores numéricos usando as funções 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

Confira também

Conversão de dados
Suporte a matemática e ponto flutuante
Localidade
_ecvt
_fcvt
_gcvt
setlocale, _wsetlocale
_atodbl, _atodbl_l, _atoldbl, _atoldbl_l, _atoflt, _atoflt_l