Page History

Narrower primitive arithmetic types can be cast to wider types without any effect on the magnitude of numeric values. However, whereas integers integer types represent exact values, floating-point numbers types have limited precision. C99 says, in Section The C Standard, 6.3.1.4 : "Real floating and integer"paragraph 3 [ISO/IEC 9899:2024], states

When a value of integer type is converted to a real standard floating type, if the value being converted can be represented exactly in the new type, it is unchanged. If the value being converted is in the range of values that can be represented but cannot be represented exactly, the result is either the nearest higher or nearest lower representable value, chosen in an implementation-defined manner. If the value being converted is outside the range of values that can be represented, the behavior is undefined.is undefined. Results of some implicit conversions may be represented in greater range and precision than that required by the new type (see 6.3.1.8 and 6.8.7.5).

Conversion from integral types to floating-point types without sufficient precision can lead to loss of precision (loss of least significant bits). No runtime exception occurs despite the loss.

Noncompliant Code Example

In this noncompliant example, an a large value of type long int is converted to float.a value of type float without ensuring it is representable in the type:

Code Block

bgColor	#FFcccc
lang	c


#include <stdio.h>

int main(void) {
  long int big = 12345678901234567890L;
  float approx = big;
  printf("%d%ld\n", (big - (long int)approx));
  return 0;
}

When compiled with GCC 4.3.2 on LinuxFor most floating-point hardware, the value closest to 1234567890 that is representable in type float is 1234567844; consequently, this program prints the value -46.

Compliant Solution

This compliant solution replaces the type float with a double. Furthermore, it uses a static an assertion to guarantee that the double type can represent any long int without loss of precision. (See recommendation DCL03INT35-C. Use a static assertion to test the value of a constant expressioncorrect integer precisions and MSC11-C. Incorporate diagnostic tests using assertions.)

Code Block

bgColor	#ccccff
lang	c

#include <assert.h>
#include <stdio<float.h>
#include <float<limits.h>

/* define or include a definition of static_assert */

static_assert(sizeof(int) * 8#include <math.h>
#include <stdint.h>
#include <stdio.h>

extern size_t popcount(uintmax_t); /* See INT35-C */
#define PRECISION(umax_value) popcount(umax_value) 

int main(void) {
  assert(PRECISION(LONG_MAX) <= DBL_MANT_DIG); // 8 = bits / char

int main() {
 * log2(FLT_RADIX));
  long int big = 12345678901234567890L;
  double approx = big;
  printf("%d%ld\n", (big - (long int)approx));
  return 0;
}

On the same platformimplementation, this program prints 0, implying that the integer value 1234567890 is representable in type double without change.

Risk Assessment

Casting numeric Conversion from integral types to floating-point types can lose informationwithout sufficient precision can lead to loss of precision (loss of least significant bits).