std::isnan (3) - Linux Manuals

std::isnan: std::isnan


std::isnan - std::isnan


Defined in header <cmath>
bool isnan( float arg ); (1) (since C++11)
bool isnan( double arg ); (2) (since C++11)
bool isnan( long double arg ); (3) (since C++11)
bool isnan( IntegralType arg ); (4) (since C++11)

1-3) Determines if the given floating point number arg is a not-a-number (NaN) value.
4) A set of overloads or a function template accepting the arg argument of any integral_type. Equivalent to (2) (the argument is cast to double).


arg - floating point value

Return value

true if arg is a NaN, false otherwise


There are many different NaN values with different sign bits and payloads, see std::nan and std::numeric_limits::quiet_NaN.
NaN values never compare equal to themselves or to other NaN values. Copying a NaN is not required, by IEEE-754, to preserve its bit representation (sign and payload), though most implementation do.
Another way to test if a floating-point value is NaN is to compare it with itself: bool is_nan(double x) { return x != x; }


// Run this code

  #include <iostream>
  #include <cmath>
  #include <cfloat>

  int main()
      std::cout << std::boolalpha
                << "isnan(NaN) = " << std::isnan(NAN) << '\n'
                << "isnan(Inf) = " << std::isnan(INFINITY) << '\n'
                << "isnan(0.0) = " << std::isnan(0.0) << '\n'
                << "isnan(DBL_MIN/2.0) = " << std::isnan(DBL_MIN/2.0) << '\n'
                << "isnan(0.0 / 0.0) = " << std::isnan(0.0/0.0) << '\n'
                << "isnan(Inf - Inf) = " << std::isnan(INFINITY - INFINITY) << '\n';


  isnan(NaN) = true
  isnan(Inf) = false
  isnan(0.0) = false
  isnan(DBL_MIN/2.0) = false
  isnan(0.0 / 0.0) = true
  isnan(Inf - Inf) = true

See also

nanl not-a-number (NaN)

fpclassify categorizes the given floating point value

isfinite checks if the given number has finite value

isinf checks if the given number is infinite

isnormal checks if the given number is normal

isunordered checks if two floating-point values are unordered