Why cast a pointer to a float into a pointer to a long, then dereference?

by 
(unsigned long)fValue

This converts the float value to an unsigned long value, according to the “usual arithmetic conversions”.

*(unsigned long *)&fValue

The intention here is to take the address at which fValue is stored, pretend that there is not a float but an unsigned long at this address, and to then read that unsigned long. The purpose is to examine the bit pattern which is used to store the float in memory.

As shown, this causes undefined behavior though.

Reason: You may not access an object through a pointer to a type that is not “compatible” to the object’s type. “Compatible” types are for example (unsigned) char and every other type, or structures that share the same initial members (speaking of C here). See ยง6.5/7 N1570 for the detailed (C11) list (Note that my use of “compatible” is different – more broad – than in the referenced text.)

Solution: Cast to unsigned char *, access the individual bytes of the object and assemble an unsigned long out of them:

unsigned long pattern = 0;
unsigned char * access = (unsigned char *)&fValue;
for (size_t i = 0; i < sizeof(float); ++i) {
  pattern |= *access;
  pattern <<= CHAR_BIT;
  ++access;
}

Note that (as @CodesInChaos pointed out) the above treats the floating point value as being stored with its most significant byte first (“big endian”). If your system uses a different byte order for floating point values you’d need to adjust to that (or rearrange the bytes of above unsigned long, whatever’s more practical to you).

More Related Contents:

  1. Regular cast vs. static_cast vs. dynamic_cast [duplicate]
  2. Why use static_cast(x) instead of (int)x?
  3. Multi-character constant warnings
  4. Is const_cast safe?
  5. What is the difference between static_cast and C style casting?
  6. Is it safe to delete a void pointer?
  7. C++ cast syntax styles
  8. Can I assume (bool)true == (int)1 for any C++ compiler?
  9. How do I avoid implicit conversions on non-constructing functions?
  10. Modifying a const through a non-const pointer
  11. C++ convert from 1 char to string?
  12. Function pointers casting in C++
  13. Why unsigned int 0xFFFFFFFF is equal to int -1?
  14. error: cast from ‘void*’ to ‘int’ loses precision
  15. Cast pointer to member function to normal pointer
  16. C++ auto vs auto&
  17. Can I cast a derived class to a private base class, using C-style cast?
  18. Passing shared_ptr as shared_ptr
  19. Why is “operator void” not invoked with cast syntax?
  20. Is reinterpret_cast type punning actually undefined behavior?
  21. Is it OK to use C-style cast for built-in types?
  22. std::lexical_cast – is there such a thing?
  23. Handling overflow when casting doubles to integers in C
  24. Is casting std::pair const& to std::pair const& safe?
  25. Understanding gsl::narrow implementation
  26. Should I use a C++ reinterpret_cast over a C-style cast?
  27. What is the modern, correct way to do type punning in C++?
  28. Why Doesn’t reinterpret_cast Force copy_n for Casts between Same-Sized Types?
  29. How to cast simple pointer to a multidimensional-array of fixed size?
  30. How can I extend a lexical cast to support enumerated types?

Leave a Comment