Question

There are some discussions about the same question but I would like to ask some more ,

1) How portable is the below code for a double byte swapping

int ReadDouble(FILE *fptr,double *n)
{
   unsigned char *cptr,tmp;

   if (fread(n,8,1,fptr) != 1)
      return(FALSE);

   cptr = (unsigned char *)n;
   tmp = cptr[0];
   cptr[0] = cptr[7];
   cptr[7] = tmp;
   tmp = cptr[1];
   cptr[1] = cptr[6];
   cptr[6] = tmp;
   tmp = cptr[2];
   cptr[2] = cptr[5];
   cptr[5] =tmp;
   tmp = cptr[3];
   cptr[3] = cptr[4];
   cptr[4] = tmp;

   return(TRUE);
} 

2) Should I keep the 3 important parts of a floating point number, sign bit, mantissa, exponent as integers and then try to manipulate them somehow.

I know the basics of floating point representations, not that deeply as a mechanical engineer, however I need to read some big-endian file where my machine is little endian. I can maybe worry about the portability issues later on. But I would like to learn about them perhaps you can direct me to some more direct things on this because there is too much information on this, I was confused which one to read.

So after some comments this should more or less do that in a portable way right? Sorry for the C file pointers…

double_t ReadDouble(ifstream& source) {
  // read 
  char buf[sizeof(double_t)];
  source.read(buf, sizeof(double_t));
  // reverse and return
  reverse( buf, buf+sizeof(double_t) );
  return *(reinterpret_cast<double_t*>(buf));
}

Best,
Umut

Answer 1

It’s not as easy as that. Just because an architecture is big-endian for integers doesn’t mean it’s big-endian for floating point numbers. I’ve heard of platforms that store integers big-endian and floats little-endian.
So first you should discover what the actual memory representation of double on your source platform is.

As for the swap itself, it’s inefficient and way too much code. An additional 8-byte buffer won’t kill you, so why not do this:

int ReadDouble(FILE* f, double* n) {
  unsigned char* nbytes = reinterpret_cast<unsigned char*>(n);
  unsigned char buf[sizeof(double)];
  if (fread(buf, sizeof(double), 1, f) != 1) return FALSE;

  for (int i = 0; i < sizeof(double); ++i) {
    nbytes[i] = buf[sizeof(double)-1-i];
  }
  return TRUE;
}

Way less code, even if you decide to manually unroll the loop.