What's the best way to use NaNs in C++?
I found std::numeric_limits<double>::quiet_NaN()
and std::numeric_limits<double>::signaling_NaN()
. I'd like to use signaling_NaN
to represent an uninitialized variable as follows:
double diameter = std::numeric_limits<double>::signaling_NaN();
This, however, signals (raises an exception) on assignment. I want it to raise an exception on use, not on assignment.
Is there any way to use signaling_NaN
without raising an exception on assignment? Is there a good, portable alternative to signaling_NaN
that will raise a floating point exception when used?
After looking into this some more, it looks like signaling_NaN
is useless as provided. If floating point exceptions are enabled, then calling it counts as processing a signaling NaN, so it immediately raises an exception. If floating point exceptions are disabled, then processing a signaling NaN automatically demotes it to a quiet NaN, so signaling_NaN
doesn't work either way.
Menkboy's code works, but trying to use signaling NaNs runs into other problems: there's no portable way to enable or disable floating point exceptions (as alluded to here and here), and if you're relying on exceptions being enabled, third party code may disable them (as described here).
So it seems like Motti's solution is really the best choice.