A few weeks ago, I wrote a C++ routine to parse decimal numbers using the overflow detection principles of SafeInt. I couldn’t find anything in the libraries that actually did a good job of checking for overflow.

Briefly, to see if unsigned values A+B overflow, check if (A > MAX_UINT - B). Similarly, A*B will overflow if (A > MAX_UINT / B).

// Convert a string to an unsigned. Returns 'true' iff conversion is legitimate.
bool
StringToUnsigned(
    const string& str,
    unsigned&     rUint)
{
    rUint = 0;

    if (str.empty())
        return false;

    for (unsigned i = 0;  i < str.length();  ++i)
    {
        if (!isdigit(str[i]))
            return false;

        // Check for numeric overflow.
        if (rUint > numeric_limits<unsigned>::max() / 10)
            return false;
        rUint *= 10;

        unsigned d = str[i] - '0';
        if (rUint > numeric_limits<unsigned>::max() - d)
            return false;
        rUint += d;
    }

    return true;
}

While debugging this code, I noticed something in­ter­est­ing. 0xFFFFFFFF divided by ten (0xA) is 0x19999999. This pattern holds for smaller and larger sequences of 0xFF…FF too: 0xFF/10 = 0x19; 0xFFFF/10 = 0x1999; and so on.

I’m not sure how to prove this, but I can prove the closely related result: 0x19…99 * 10 = 0xFF…FA:

10 * N         = 8 * N  +  2 * N
10 * 0x19...99 = 8 * 0x19...99  +  2 * 0x19...99

0x199...99     =   %0001 1001 1001 ... 1001 1001

10 * 0x19...99 =   %1100 1100 1100 ... 1100 1000
                 + %0011 0011 0011 ... 0011 0010
               =   %1111 1111 1111 ... 1111 1010

A mildly curious result of no value, but it amused me.