2009-11-10 23 views
8

Tengo una base de datos llena con dobles como el siguiente:cadena en notación C. científica ++ a doble conversión

1.60000000000000000000000000000000000e+01 

¿Alguien sabe cómo convertir un número de esa manera a un doble en C++?

¿Hay una manera "estándar" para hacer este tipo de cosas? ¿O tengo que rodar mi propia función?

En este momento estoy haciendo algo como esto:

#include <string> 
#include <sstream> 



int main() { 
    std::string s("1.60000000000000000000000000000000000e+01"); 
    std::istringstream iss(s); 
    double d; 
    iss >> d; 
    d += 10.303030; 
    std::cout << d << std::endl; 
} 

Gracias!

+2

¿Qué tipo de base de datos? ¿Cuál es el esquema de la base de datos alrededor de ese campo? –

+0

¿Cuál es la precisión que necesita para mantener este número? Si, mantener esa alta precisión no es un problema, puedes "cortar" esta cuerda y convertirla a doble usando las funciones comunes de C. – Andres

+0

Tenga en cuenta que debe verificar el estado de la secuencia de cadenas después de leer de ella. La lectura puede fallar – sbi

Respuesta

16

Algo como esto? Esta sería la forma de "C++" de hacerlo ...

#include <sstream> 
using namespace std; 

// ... 

    string s = "1.60000000000000000000000000000000000e+01"; 
    istringstream os(s); 
    double d; 
    os >> d; 
    cout << d << endl; 

imprime 16.

+4

Si tienes impulso, entonces 'doble d = boost :: lexical_cast (s)' se hacer la misma cosa. –

+0

¿Se supone que esto funciona si cambiamos el tipo a "int"? Parece que solo saco el cero, ¿la rutina no puede manejar la notación exponencial, a pesar de que representa un número entero? –

+0

[Es complicado] (http://en.cppreference.com/w/cpp/locale/num_get/get) pero probablemente no. – Thomas

7

Desea la función c estándar atof ([A] SCII a [F] loat, pero en realidad usa dobles en lugar de flotadores).

+1

Esto será mucho más rápido que usar objetos de transmisión en C++. –

+0

atof se convierte en un doble como OP y dice el documento. – luke

+2

@Heath: Siempre es fácil ser rápido cuando se salta pasos importantes: 'atof ("0.0")' 'vs atof ("bla")'. (Nota: No estoy tratando de defender las corrientes C++, que _are_ lento de lo que debería ser, pero sí indican errores en una forma no ambigua..) – sbi

Cuestiones relacionadas