在c ++中将双数转换为（IEEE 754）64位二进制字符串表示

Question

I have a double number, I want to represent it in IEEE 754 64-bit binary string. Currently i'm using a code like this:

double noToConvert;
unsigned long* valueRef = reinterpret_cast<unsigned long*>(&noToConvert);

bitset<64> lessSignificative(*valueRef);
bitset<64> mostSignificative(*(++valueRef));

mostSignificative <<= 32;
mostSignificative |= lessSignificative;

RowVectorXd binArray = RowVectorXd::Zero(mostSignificative.size());
for(unsigned int i = 0; i <mostSignificative.size();i++)
{
    (mostSignificative[i] == 0) ? (binArray(i) = 0) : (binArray(i) = 1);
} 

The above code just works fine without any problem. But If you see, i'm using reinterpret_cast and using unsigned long. So, this code is very much compiler dependent. Could anyone show me how to write a code that is platform independent and without using any libraries. i'm ok, if we use the standard libraries and even bitset, but i dont want to use any machine or compiler dependent code.

Thanks in advance.

Answer 1

If you're willing to assume that double is the IEEE-754 double type:

#include <cstdint>
#include <cstring>

uint64_t getRepresentation(const double number) {
    uint64_t representation;
    memcpy(&representation, &number, sizeof representation);
}

If you don't even want to make that assumption:

#include <cstring>

char *getRepresentation(const double number) {
    char *representation = new char[sizeof number];
    memcpy(representation, &number, sizeof number);
    return representation;
}

Answer 2

Why not use the union?

bitset<64> binarize(unsigned long* input){
    union binarizeUnion   
    {
        unsigned long* intVal;
        bitset<64> bits;
    } binTransfer;
    binTransfer.intVal=input;
    return (binTransfer.bits);
}

Answer 3

The simplest way to get this is to memcpy the double into an array of char :

char double_as_char[sizeof(double)];
memcpy(double_as_char, &noToConvert, sizeof(double_as_char));

and then extract the bits from double_as_char . C and C++ define that in the standard as legal.

Now, if you want to actually extract the various components of a double , you can use the following:

sign= noToConvert<=-0.0f;
int exponent;
double normalized_mantissa= frexp(noToConvert, &exponent);
unsigned long long mantissa= normalized_mantissa * (1ull << 53);

Since the value returned by frexp is in [0.5, 1) , you need to shift it one extra bit to get all the bits in the mantissa as an integer. Then you just need to map that into the binary represenation you want, although you'll have to adjust the exponent to include the implicit bias as well.

Answer 4

The function print_raw_double_binary() in my article Displaying the Raw Fields of a Floating-Point Number should be close to what you want. You'd probably want to replace the casting of double to int with a union, since the former violates "strict aliasing" (although even use of a union to access something different than what is stored is technically illegal).