Byte Swapping Floats

How do I go about swapping bytes (little endian -> big endian and visa-versa) in a platform independent way.

I saw this:

Code:

float FloatSwap( float f )
{
  union
  {
    float f;
    unsigned char b[4];
  } dat1, dat2;

  dat1.f = f;
  dat2.b[0] = dat1.b[3];
  dat2.b[1] = dat1.b[2];
  dat2.b[2] = dat1.b[1];
  dat2.b[3] = dat1.b[0];
  return dat2.f;
}

However apparently there are some situations where it causes problems:

double swap(double) Doesn't Work

I cant seem to get the correct values from the above function anyway. The dat2.f returned is always 0.0

Many Thanks,
-Alex

Originally Posted by alexcurtis

I cant seem to get the correct values from the above function anyway. The dat2.f returned is always 0.0

Why would you expect otherwise? By byte-swapping the value you've totally ruined it.

The function should return an unsigned int (or more specifically, some integer type which is 32 bits in size), not a float. And you should not attempt to interpret the value as a float.

Originally Posted by brewbuck

Why would you expect otherwise? By byte-swapping the value you've totally ruined it.

The function should return an unsigned int (or more specifically, some integer type which is 32 bits in size), not a float. And you should not attempt to interpret the value as a float.

OK. No Problem.

Am I still going to run into problems on machines (with a different endian than the machine that wrote the file) when they try to decode it?

-Alex

Originally Posted by alexcurtis

OK. No Problem.

Am I still going to run into problems on machines (with a different endian than the machine that wrote the file) when they try to decode it?

-Alex

Only if the two architectures use the same size and type of floats. If you want it really portable you should communicate the floating point integers in another format. Simple text is quite common and can be written and read directly using streams.

Originally Posted by EVOEx

Only if the two architectures use the same size and type of floats. If you want it really portable you should communicate the floating point integers in another format. Simple text is quite common and can be written and read directly using streams.

Im afraid I can't do that. Im writing to a specific file format that is binary and big-endian.

Something like this?

Code:

#include <stdio.h>

void swapbytes(void *object, size_t size)
{
   unsigned char *start, *end;
   for ( start = object, end = start + size - 1; start < end; ++start, --end )
   {
      unsigned char swap = *start;
      *start = *end;
      *end = swap;
   }
}

void showbytes(const void *object, size_t size)
{
   unsigned char *byte = object;
   size_t i;
   for ( i = 0; i < size; ++i )
   {
      printf("%02X", (unsigned)*byte++);
   }
   putchar('\n');
}

int main()
{
   unsigned long value = 0x12345678UL;
   showbytes(&value, sizeof value);
   swapbytes(&value, sizeof value);
   showbytes(&value, sizeof value);
   return 0;
}

/* my output
78563412
12345678
*/

Originally Posted by alexcurtis

Im afraid I can't do that. Im writing to a specific file format that is binary and big-endian.

Then you should probably decode the floating point number (get the mantissa, exponent and sign) and write that to the binary file. Unless the file format doesn't have to be portable.

Originally Posted by EVOEx

Then you should probably decode the floating point number (get the mantissa, exponent and sign) and write that to the binary file. Unless the file format doesn't have to be portable.

"specific file format" seems to imply the format is pre-defined.

Originally Posted by brewbuck

"specific file format" seems to imply the format is pre-defined.

Oops, I misread it. I stand corrected.
Then you may have to decode it on certain architectures and save it in the architecture's representation for floating point numbers. Again, if it needs portability to such systems.