Determining scale (length of fractional part) in floating-point calculations

Hello,

Is there a standard way of determining the scale - length of the fractional
part, such as 2 for 0.01 - of a floating-point number? I am trying to devise
a reliable method that would not be looking for the dot (.) in the
std::string.

This is what I have come up with so far but it does not look too reliable:

inline int get_scale(double d)
{
    const int MAX_DEC_PLACES = 10;

    int sc = 0;
    double ip;
    for (double r = std::abs(std::modf(d, &ip)); !eq(d, ip) && ++sc <
MAX_DEC_PLACES; r = std::abs(std::modf(d *= 10., &ip)));
    return sc;
}

(std::modf() places the fractional and the integral parts into separate
variables and the method then, multiplying the original number by 10 and
increasing the scale by 1 on each iteration, tests the number and its
integral part for equality, the point being that when they compare equal,
the fractional part will be 0 and we will have determined the scale)

Here is the function that does the comparison above:

inline double eq(const double x, const double y)
{
    if (std::abs(x - y) < std::numeric_limits<double>::epsilon()) return
true;
    return std::abs((x - y) / (std::abs(x) < std::abs(y) ? y : x)) <
0.00001;
}

This did not give the correct result for 41548.76523: the equality appears
to have been achieved too early.

Perhaps there is an established method of doing it - but I have browsed the
Internet, to no avail, it would seem

Thank you.

Paul