C++ gotcha: numeric_limits::min() doesn't do what you'd think

I use C++ every day, but boy it is annoying sometimes. It has little symantec flaws that catch you. You can use numeric_limits to avoid hardcoding a "big number". Given that

numeric_limits<int>::max() is 2147483647numeric_limits<int>::min() is -2147483648numeric_limits<double>::max() is 1.79769e+308

What do you suppose numeric_limits<double>::min() would be?

I assumed it would be -1.79769e+308, but no. It is 2.22507e-308, the smallest positive double value. What the hell? If you want to return that, give it a better name.

Sure, I realize that I can use -numeric_limits<double>::max(), but boy that is confusing and makes template code based on this impossible. Asking around the office, everyone seemed to know the value, and they all found out the hard way by having a bug in their code.

Comments

Same story with Java:
Double.MAX_VALUE; // 1.7976931348623157e+308; 0x1.fffffffffffffP+1023

Double.MIN_VALUE; // 4.9e-324; 0x0.0000000000001P-1022

However (a little ad compain for floating point users :-)

1) no floating point exceptions, unlike in C or C++ (Java will be upset only in the rare case of integer division by zero, which is presumably a bug easy to avoid.)

2) you can always catch an intermediate Double.NaN or Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY
(Double.isInfinite(value) or Double.isNaN(value)) in case things transcended beyond tangible. Since NaNs or Infinities can be reliably caught, you can always backtrack.
For instance in an iterative process it is typically possible to analyze intermediate vector's norm (cheap computation: once an INFINITY or NAN kicks in, it is propagated and cannot be cancelled 0 * POSITIVE_INFINITY == NAN, etc.)