用C ++解析float函数

Question

My question is regarding the solution posted by 6502 on [ c++ stringstream is too slow, how to speed up? Parsing Float method posted by him is fast but its not giving correct result on large double values.

Input:

132.12345645645645

Output:

132.123

double parseFloat(const std::string& input){
    const char *p = input.c_str();
    if (!*p || *p == '?')
        return NAN_D;
    int s = 1;
    while (*p == ' ') p++;

    if (*p == '-') {
        s = -1; p++;
    }

    double acc = 0;
    while (*p >= '0' && *p <= '9')
        acc = acc * 10 + *p++ - '0';

    if (*p == '.') {
        double k = 0.1;
        p++;
        while (*p >= '0' && *p <= '9') {
            acc += (*p++ - '0') * k;
            k *= 0.1;
        }
    }
    if (*p) die("Invalid numeric format");
    return s * acc;
}

I want to know is there any way to change this function to get correct result.

Answer 1

If you're printing the result with cout, make sure you set the necessary precision:

cout.precision(20);

live example

However as you noted a simpler method would be:

double string_to_double( const std::string& s )
 {
   std::istringstream i(s);
   double x;
   if (!(i >> x))
     return std::numeric_limits<double>::quiet_NaN(); // Or anything you prefer
   return x;
 }

Notice: due to roundoff errors, exceeding with the number of digits might not yield 100% expected results on the rightmost part.

Answer 2

The scaling for the digits after the decimal point is significantly worse than useless.

Multiplying by 0.1 is a mistake ... not least because 0.1 is not represented exactly in binary floating point. So going round in a loop, repeatedly multiplying by 0.1 is accumulating more and more error.

For big numbers, when multiplying the number so far by 10, and adding the next digit value, you are going to accumulate more errors :-(

The trick is to accumulate the digits as an unsigned long long (assuming that's at least 64 bits), ignoring the . but counting the number of digits after it. When you have all the digits, float the integer and then divide by the required power of 10. Now you have at most one rounding (in the float, if you have more than 53 bits of value) and a second in the division. But, things can get complicated... if you have a number whose value exceeds what you can fit in an unsigned long long , you need to stop adding digits (and round)... if that happens before the . , you need to count digits up to it, and then multiply by a power of 10.

NB : decimal to binary floating point conversion is hard in the general case. If you are converting numbers without exponents, and the number of digits is reasonable, it's not too bad. The problem that bites you is how to create large powers of 10 to multiply/divide by, without introducing (unacceptable) errors.