creating a double precision value from individual bytes

**garethv** · 08-02-2011

Hi,

Could anybody tell me if they know of any tricks with pointers or any functions in standard libraries that would allow me to do this:
I am interfacing with a piece of hardware that returns the 64 bits of a double precision value as an array of 8 bytes. These correspond to the 64 bits used for a double precision number. Other than resorting to using the equation (such as in wikipedia) to generate this value, I was hoping I could directly allocate these bytes to a pointer to double but so far I haven't found a way to do this. Is it possible?

Thanks,

Gareth

**Salem** · 08-02-2011

So long as your 8 bytes are in the correct byte order for the endian of your machine, then you can do

Code:

memcpy( &myDouble, mybuffer, sizeof(myDouble) );

But you're making a few assumptions by doing this.

**itCbitC** · 08-02-2011

Originally Posted by garethv

... I was hoping I could directly allocate these bytes to a pointer to double but so far I haven't found a way to do this. Is it possible?

Yep, just point a double* to the base of the 8 byte char array and dereference it.

**Salem** · 08-02-2011

> Yep, just point a double* to the base of the 8 byte char array and dereference it.
Better watch out for those alignment exceptions then, if such a pointer were to be mis-aligned for a double.

**itCbitC** · 08-02-2011

Originally Posted by Salem

> Yep, just point a double* to the base of the 8 byte char array and dereference it.
Better watch out for those alignment exceptions then, if such a pointer were to be mis-aligned for a double.

Good point!

@OP:
Based on Salem's comment, explicitly specify a #pragma pack(8) directive to ensure proper alignment.

**~~CommonTater~~** · 08-02-2011

Originally Posted by itCbitC

Good point!

@OP:
Based on Salem's comment, explicitly specify a #pragma pack(8) directive to ensure proper alignment.

Which, as far as I know, only works on structs.

**itCbitC** · 08-02-2011

Originally Posted by CommonTater

Which, as far as I know, only works on structs.

Hmm! you are right and I wonder WTH I was thinking of, albeit alignment and indirection can be eliminated by unionizing an 8 byte char array and a double.

**iMalc** · 08-03-2011

itCbitC: Ever get the feeling that you're digging a hole?
"The hardware returns is as an array of 8 bytes". Either the hardware aligns it or it doesn't. It's not a case of trying to write code that makes sure it is already aligned. It is a case of ... just align the damm thing.

The memcpy is probably the best option.

**garethv** · 08-03-2011

Thanks for all your help! The memcpy solution seems to work fine and is just what I was looking for. As this will only be used on Windows machines I guess I'm safe to assume the order won't change.

**~~CommonTater~~** · 08-03-2011

Originally Posted by garethv

Thanks for all your help! The memcpy solution seems to work fine and is just what I was looking for. As this will only be used on Windows machines I guess I'm safe to assume the order won't change.

The only thing that's safe to assume is that "It works this time"... to get beyond that requires testing.

**kmdv** · 08-03-2011

If you want to be sure about the correct alignment, just use a union:

Code:

union {
    char from_hardware[sizeof(double)];
    double to_software;
};

It is better than the #pragma.

Thread: creating a double precision value from individual bytes

Thread Tools

Search Thread

Display

creating a double precision value from individual bytes

Similar Threads

Accesing individual bytes in an int

Manipulating individual bits in a double precision number

extended vs double precision

More precision than a double

Reading Individual bits from 2 bytes

Tags for this Thread