resueltos - ¿Cómo puedo convertir cadenas en dobles en C++?

ejercicios resueltos de cadenas en c++

Question

¿Cómo puedo convertir cadenas en dobles en C ++? Quiero una función que devuelva 0 cuando la cadena no es numérica.

Answer 1

Creo que http://www.cplusplus.com/reference/clibrary/cstdlib/atof.html es exactamente lo que quieres. Esta función analiza una cadena y la convierte en un doble. Si la cadena no comienza con un número (no numérico), se devuelve 0.0.

Sin embargo, intenta analizar tanto de la cadena como sea posible. En otras palabras, la cadena "3abc" se interpretaría como 3.0. Si desea una función que devolverá 0.0 en estos casos, tendrá que escribir un pequeño contenedor usted mismo.

Además, esta función funciona con la cadena estilo C de una matriz de caracteres terminada nula. Si está utilizando un objeto de cadena, tendrá que convertirse a un char * antes de usar esta función.

Answer 2

Debo decir que estoy de acuerdo con que la solución más elegante es usar boost :: lexical_cast. Luego puede atrapar el bad_lexical_cast que podría ocurrir y hacer algo cuando falla, en lugar de obtener 0.0 que atof da.

#include <boost/lexical_cast.hpp>
#include <string>
int main()
{
std::string str = "3.14";
double strVal;
try {
strVal = boost::lexical_cast<double>(str);
} catch(bad_lexical_cast&) {
//Do your errormagic
}
return 0;
}

Answer 3

La forma más simple es usar boost::lexical_cast :

double value;
try
{
value = boost::lexical_cast<double>(my_string);
}
catch (boost::bad_lexical_cast const&)
{
value = 0;
}

Answer 4

No hay una sola función que lo haga, porque 0 es un número válido y debe ser capaz de detectar cuando la cadena no es un número válido.

Deberá verificar primero la cadena (probablemente con una expresión regular) para ver si contiene solo números y puntuación numérica. A continuación, puede decidir devolver 0 si eso es lo que necesita su aplicación o convertirla en un doble.

Después de buscar atof () y strtod () debería reformular mi declaración a "no debería haber" en lugar de "no hay" ... jeje

Answer 5

Si es una cadena de caracteres (matriz terminada en nulo de tipo char), puede hacer algo como:

#include <stdlib.h>
char str[] = "3.14159";
double num = atof(str);

Si es una cadena de C ++, simplemente use el método c_str ():

double num = atof( cppstr.c_str() );

atof () convertirá la cadena en un doble, devolviendo 0 en caso de falla. La función está documentada aquí: http://www.cplusplus.com/reference/clibrary/cstdlib/atof.html

Answer 6

Una de las soluciones más elegantes a este problema es usar boost :: lexical_cast como lo mencionó @Evgeny Lazin.

Answer 7

atof y strtod hacen lo que quieren, pero son muy indulgentes. Si no quiere aceptar cadenas como "32asd" como válidas, debe ajustar strtod en una función como esta:

#include <stdlib.h>
double strict_str2double(char* str)
{
char* endptr;
double value = strtod(str, &endptr);
if (*endptr) return 0;
return value;
}

Answer 8

Ver C ++ FAQ Lite ¿Cómo convierto un std :: string a un número?

Ver C ++ Super-FAQ ¿Cómo convierto un std :: string a un número?

Tenga en cuenta que con sus requisitos no puede distinguir todas las representaciones de cadena permitidas de cero de las cadenas no numéricas.

 // the requested function
#include <sstream>
double string_to_double( const std::string& s )
{
std::istringstream i(s);
double x;
if (!(i >> x))
return 0;
return x;
}
// some tests
#include <cassert>
int main( int, char** )
{
// simple case:
assert( 0.5 == string_to_double( "0.5" ) );
// blank space:
assert( 0.5 == string_to_double( "0.5 " ) );
assert( 0.5 == string_to_double( " 0.5" ) );
// trailing non digit characters:
assert( 0.5 == string_to_double( "0.5a" ) );
// note that with your requirements you can''t distinguish
// all the the allowed string representation of zero from
// the non numerical strings:
assert( 0 == string_to_double( "0" ) );
assert( 0 == string_to_double( "0." ) );
assert( 0 == string_to_double( "0.0" ) );
assert( 0 == string_to_double( "0.00" ) );
assert( 0 == string_to_double( "0.0e0" ) );
assert( 0 == string_to_double( "0.0e-0" ) );
assert( 0 == string_to_double( "0.0e+0" ) );
assert( 0 == string_to_double( "+0" ) );
assert( 0 == string_to_double( "+0." ) );
assert( 0 == string_to_double( "+0.0" ) );
assert( 0 == string_to_double( "+0.00" ) );
assert( 0 == string_to_double( "+0.0e0" ) );
assert( 0 == string_to_double( "+0.0e-0" ) );
assert( 0 == string_to_double( "+0.0e+0" ) );
assert( 0 == string_to_double( "-0" ) );
assert( 0 == string_to_double( "-0." ) );
assert( 0 == string_to_double( "-0.0" ) );
assert( 0 == string_to_double( "-0.00" ) );
assert( 0 == string_to_double( "-0.0e0" ) );
assert( 0 == string_to_double( "-0.0e-0" ) );
assert( 0 == string_to_double( "-0.0e+0" ) );
assert( 0 == string_to_double( "foobar" ) );
return 0;
}

Answer 9

#include <iostream>
#include <string>
using namespace std;
int main()
{
cout << stod(" 99.999 ") << endl;
}

Salida: 99.999 (que es doble, el espacio en blanco se eliminó automáticamente)

Dado que C ++ 11 convierte cadena a valores de punto flotante (como el doble) está disponible con funciones:
stof - convierte str a un flotador
stod - convierte str a doble
stold - convierte str a un doble largo

Quiero una función que devuelva 0 cuando la cadena no es numérica.

Puede agregar la declaración try catch cuando stod arroja una excepción.