How do I convert a string to double using only math.h

I'm trying to convert a 开发者_JS百科string to a double, but since I'm working on a Windows native application (as in linking only to ntdll.dll), I don't have most of the standard library available. I can use basic FP support in math.h, but that's basically it.

How do I convert a string to the double closest to the rational number expressed in that string?

---

If you really want to get the nearest, the problem is quite hard and you need arbitrary precision arithmetic to achieve that result. See ftp://ftp.ccs.neu.edu/pub/people/will/howtoread.ps for instance.

---

Have you seen Open NT Native Template Library, particularly the STLx part? Basically, you get something close to normal C++ runtime in Native or Kernel code.

---

Assuming the JSON grammar (link currently down, Google cached version here) is acceptable to you, the following comes more or less direct from internally developed code for JSON parsing, being a literal implementation of its syntax diagram:

/*

    defined functions for handling the input:

        nextChar() - peeks at the next character of input

        getAndRemoveCharacter() - returns the next character of input and
        dequeues it

    This code also assumes you have BOOL, YES and NO defined; I've left this in
    for clarity
*/

double getNumber()
{
    // determine whether the number is negative - it'll start with a '-' if so
    BOOL negative = NO;
    if(nextChar() == '-')
    {
        negative = YES;
        getAndRemoveCharacter();
    }

    // seed the output number to 0
    double number = 0.0;

    // if the next character isn't a '0' then this is the number proper, so
    // just pull off the digits and assemble the number; otherwise this number
    // is either 0 itself (in which case the initial seed is correct) or a
    // decimal starting in 0
    if(nextChar() != '0')
    {
        while(nextChar() >= '0' && nextChar() <= '9')
        {
            number *= 10.0;
            number += getAndRemoveCharacter() - '0';
        }
    }
    else
        getAndRemoveCharacter();

    // if this is a decimal then jump on to the decimal part and deserialise
    // digits, much as above
    if(nextChar() == '.')
    {
        getAndRemoveCharacter();
        double decimalMultiplier = 1.0;
        while(nextChar() >= '0' && nextChar() <= '9')
        {
            decimalMultiplier /= 10.0;
            number += (double)(getAndRemoveCharacter() - '0') * decimalMultiplier;
        }
    }

    // if this number has an exponent then deal with that
    if(nextChar() == 'e' || nextChar() == 'E')
    {
        getAndRemoveCharacter();

        double exponent = 0.0;
        BOOL exponentPositive = YES;

        // JSON allows positive exponents to start with + (unlike
        // the mantissa) and requires negative exponents to start with -
        if(nextChar() == '+')
        {
            getAndRemoveCharacter();
        }
        else
            if(nextChar() == '-')
            {
                exponentPositive = NO;
                getAndRemoveCharacter();
            }

        // read out digits and assemble exponent
        while(nextChar() >= '0' && nextChar() <= '9')
        {
            exponent *= 10.0;
            exponent += getAndRemoveCharacter() - '0';
        }

        // apply exponent
        number *= pow(10.0, exponentPositive ? exponent : -exponent);
    }

    // negate if necessary and return
    return negative ? -number : number;
}

Any character type that puts the ASCII letters in the normal ASCII range will work, so it should work equally on ASCII and variants, and unicode. I guess you'd probably want to just take a string directly as an argument rather than do all those calls out; they're their in the original because the input stream is coming from afar, so they may block.

The only math.h function used in 'pow', everything else is just primitive operations.