## Can an integer be NaN in C++?

No, NaN is a floating point value.

Every possible value of an `int`

is a number.

#### Edit

The standard says:

6.2.6.240) Some combinations of padding bits might generate trap

representations, for example, if one

padding bit is a parity bit.

Regardless,no arithmetic operation onother than as part of

valid values can generate a trap

representation

an exceptional condition such as an

overflow, and this cannot occur with

unsigned types.

So there *may* be some implementation specific invalid integer values, but there is no defined way to generate them.

## How to use nan and inf in C?

You can test if your implementation has it:

`#include <math.h>`

#ifdef NAN

/* NAN is supported */

#endif

#ifdef INFINITY

/* INFINITY is supported */

#endif

The existence of `INFINITY`

is guaranteed by C99 (or the latest draft at least), and "expands to a constant expression of type float representing positive or unsigned

infinity, if available; else to a positive constant of type float that overflows at translation time."

`NAN`

may or may not be defined, and "is defined if and only if the implementation supports quiet NaNs for the float type. It expands to a constant expression of type float representing a quiet NaN."

Note that if you're comparing floating point values, and do:

`a = NAN;`

even then,

`a == NAN;`

is false. One way to check for NaN would be:

`#include <math.h>`

if (isnan(a)) { ... }

You can also do: `a != a`

to test if `a`

is NaN.

There is also `isfinite()`

, `isinf()`

, `isnormal()`

, and `signbit()`

macros in `math.h`

in C99.

C99 also has `nan`

functions:

`#include <math.h>`

double nan(const char *tagp);

float nanf(const char *tagp);

long double nanl(const char *tagp);

(Reference: n1256).

Docs INFINITY

Docs NAN

## Problems casting NAN floats to int

The result of a cast of a floating point number to an integer is undefined/unspecified for values not in the range of the integer variable (±1 for truncation).

Clause 6.3.1.4:

When a finite value of real floating type is converted to an integer type other than

`_Bool`

, the fractional part is discarded (i.e., the value is truncated toward zero). If the value of the integral part cannot be represented by the integer type, the behavior is undefined.

If the implementation defines `__STDC_IEC_559__`

, then for conversions from a floating-point type to an integer type other than `_BOOL`

:

if the floating value is infinite or NaN or if the integral part of the floating value exceeds the range of the integer type, then the "invalid" floating-

point exception is raised and the resulting value is unspecified.

(Annex F [normative], point 4.)

If the implementation doesn't define `__STDC_IEC_559__`

, then all bets are off.

## What is the result of casting float +INF, -INF, and NAN to integer in C?

As Paul said, it's undefined:

From §6.3.1.4:

6.3.1.4 Real ﬂoating and integer

When a ﬁnite value of real ﬂoating type is

converted to an integer type other

than _Bool, the fractional part is

discarded (i.e., the value is

truncated toward zero). If the value

of the integral part cannot be

represented by the integer type, the

behavior is undeﬁned.50)

Infinity isn't finite, and the integral part can't be represented in an integral type, so it's undefined.

## How to produce a NaN float in c?

Using floating point numbers, `0.0 / 0.0`

isn't a "divide by zero" error; it results in `NaN`

.

This C program prints `-nan`

:

`#include <stdio.h>`

int main()

{

float x = 0.0 / 0.0;

printf("%f\n", x);

return 0;

}

In terms what `NaN`

looks like to the computer, two "invalid" numbers are reserved for "signaling" and "quiet" NaN (similar to the two invalid numbers reserved for positive and negative infinity). The Wikipedia entry has more details about how NaN is represented as an IEE floating point number.

## Objective-C: int can´t be NAN?

`NaN`

is a value that is specific to the way that floating point numbers (`float`

and `double`

in C) are represented internally (IEEE 754). Is is not available for integer data types, as they may be represented in a completely different manner.

As a workaround, you may see people use a separate boolean flag to indicate if a value is valid, or the extreme values `INT_MIN`

/`INT_MAX`

. Although, nether of these is as good as `NaN`

for ensuring valid values.

### Related Topics

Does Std::Cout Have a Return Value

Enumdisplaydevices VS Wmi Win32_Desktopmonitor, How to Detect Active Monitors

Correct Format for Http Post Using Qnetworkrequest

Find Two Elements in an Array That Sum to K

Calculate System Time Using Rdtsc

Braces Around String Literal in Char Array Declaration Valid? (E.G. Char S[] = {"Hello World"})

Std::Remove_If - Lambda, Not Removing Anything from the Collection

Do Function Pointers Need an Ampersand

How to Generate a Newline in a Cpp MACro

How to Run the Preprocessor on Local Headers Only

How to Handle a Transitive Dependency Conflict Using Git Submodules and Cmake

Why Does Pointer to Int Convert to Void* But Pointer to Function Convert to Bool

Why Do We Need to Tie Std::Cin and Std::Cout

Algorithm to Add or Subtract Days from a Date

Why Can't C++11 Move a Noncopyable Functor to a Std::Function