Convert between little-endian and big-endian floats effectively

Question

I have a working software, which currently runs on a little-endian architecture. I would like to make it run in big-endian mode too. I would like to write little-endian data into files, regardless of the endianness of the underlying system.

To achieve this, I decided to use the boost endian library. It can convert integers efficiently. But it cannot handle floats (and doubles).

It states in the documentation, that "Floating point types will be supported in the Boost 1.59.0". But they are still not supported in 1.62.

I can assume, that the floats are valid IEEE 754 floats (or doubles). But their endianness may vary according to the underlying system. As far as I know, using the htonl and ntohl functions on floats is not recommended. How is it possible then? Is there any header-only library, which can handle floats too? I was not able to find any.

I could convert the floats to string, and write that into a file, I would like to avoid that method, for many reasons ( performance, disk-space, ... )

No need for any lib, it's pretty immediate. Have a look there : http://stackoverflow.com/questions/2782725/converting-float-values-from-big-endian-to-little-endian — aCOSwt, Dec 19 '16 at 10:41

score 1 · Answer 1 · edited Dec 20 '16 at 00:23

1

Here:

float f = 1.2f;
auto it = reinterpret_cast<uint8_t*>(&f);
std::reverse(it, it + sizeof(f)); //f is now in the reversed endianness

No need for anything fancy.

edited Dec 20 '16 at 00:23

Unheilig

16,196
193
68
98

answered Dec 19 '16 at 18:25

David Haim

25,446
3
44
78

score 1 · Answer 2 · answered May 18 '17 at 01:41

Unheilig: you are correct, but

#include <boost/endian/conversion.hpp>


template <typename T>
inline T endian_cast(const T & t)
{
#ifdef BOOST_LITTLE_ENDIAN
    return boost::endian::endian_reverse(t);
#else
    return t;
#endif
}

or when u are using pointers, to immediate reversing, use:

template <typename T>
inline T endian_cast(T *t)
{
#ifdef BOOST_LITTLE_ENDIAN
    return boost::endian::endian_reverse_inplace(*t);
#else
    return t;
#endif
}

and use it, instead of manually (or maybe error-prone) reversing it's content

example:

std::uint16_t start_address() const
{
    std::uint16_t address;
    std::memcpy(&address, &data()[1], 2);
    return endian_cast(address);
}
void start_address(std::uint16_t i)
{
    endian_cast(&i);
    std::memcpy(&data()[1], &i, 2);
}

Good luck.

No overload for floats [1](http://www.boost.org/doc/libs/1_65_0/libs/endian/doc/conversion.html). but one still need to force reversing the endian — ar2015, Mar 15 '18 at 03:05

score 1 · Answer 3 · answered Apr 26 '20 at 19:48

When serializing float/double values, I make the following three assumptions:

The machine representation follows IEEE 754
The endianess of float/double matches the endianess of integers
The behavior of reinterpret_cast-ing between double&/int64_t& or float&/int32_t& is well-defined (E.g., the cast behaves as if the types are similar).

None of these assumptions is guaranteed by the standard. Under these assumptions, the following code will ensure doubles are written in little-endian:

ostream out;
double someVal;
...
static_assert(sizeof(someVal) == sizeof(int64_t),
    "Endian conversion requires 8-byte doubles");
native_to_little_inplace(reinterpret_cast<int64_t&>(someVal));
out.write(reinterpret_cast<char*>(&someVal), sizeof(someVal));

I probably should have added that `boost::endian::native_to_little_inplace` is defined in *boost/endian/conversion.hpp*. — Jeff G, Apr 27 '20 at 13:54

Convert between little-endian and big-endian floats effectively

3 Answers3

Linked