Isnan

Defined in header <cmath>.

Description

Determines if the given floating point number num is a not-a-number (NaN) value.
​The library provides overloads for all cv-unqualified floating-point types as the type of the parameter num  (od C++23).

​Additional Overloads are provided for all integer types, which are treated as double.

Declarations

C++23

// 1)
constexpr bool isnan( /* floating-point-type */ num );

Additional Overloads

// 2)
template< class Integer >
constexpr bool isnan( Integer num );

C++11

// 1)
bool isnan( float num );
// 2)
bool isnan( double num );
// 3)
bool isnan( long double num );

Additional Overloads

// 4)
template< class Integer >
bool isnan( Integer num );

Parameters

​num - floating-point or integer value

Return value

true if num is a NaN, false otherwise.

Notes

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; }.

The additional overloads are not required to be provided exactly as Additional Overloads. They only need to be sufficient to ensure that for their argument num of integer type,
std::isnan(num) has the same effect as std::isnan(static_cast<double>(num)).

Examples

#include <cfloat>
#include <cmath>
#include <iostream>
 
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';
}

Possible Result

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