Блог

В Java Double.doubleToLongBits() это полезно для реализации hashCode() методов.

Я пытаюсь сделать то же самое на C и написать свой собственный doubleToRawLongBits() метод, так как после поиска в Google я не могу найти подходящую реализацию.

Я могу получить значение и показатель степени из std::frexp(numbr,amp;exp) и могу определить знак, но не могу понять использование побитовых операторов для получения эквивалента Java.

Например, Java Double.doubleToLongBits() возвращает следующее для double 3.94:

4616054510065937285

Спасибо за любую помощь.

Грэм

Ниже приведена документация, скопированная и вставленная из Double.Двойные или длинные биты()

 ===Java Double.doubleToRawLongBits() description===

/**
     * Returns a representation of the specified floating-point value
     * according to the IEEE 754 floating-point "double
     * format" bit layout, preserving Not-a-Number (NaN) values.
     * <p>
     * Bit 63 (the bit that is selected by the mask 
     * <code>0x8000000000000000L</code>) represents the sign of the 
     * floating-point number. Bits 
     * 62-52 (the bits that are selected by the mask 
     * <code>0x7ff0000000000000L</code>) represent the exponent. Bits 51-0 
     * (the bits that are selected by the mask 
     * <code>0x000fffffffffffffL</code>) represent the significand 
     * (sometimes called the mantissa) of the floating-point number. 
     * <p>
     * If the argument is positive infinity, the result is
     * <code>0x7ff0000000000000L</code>.
     * <p>
     * If the argument is negative infinity, the result is
     * <code>0xfff0000000000000L</code>.
     * <p>
     * If the argument is NaN, the result is the <code>long</code>
     * integer representing the actual NaN value.  Unlike the
     * <code>doubleToLongBits</code> method,
     * <code>doubleToRawLongBits</code> does not collapse all the bit
     * patterns encoding a NaN to a single amp;quot;canonicalamp;quot; NaN
     * value.
     * <p>
     * In all cases, the result is a <code>long</code> integer that,
     * when given to the {@link #longBitsToDouble(long)} method, will
     * produce a floating-point value the same as the argument to
     * <code>doubleToRawLongBits</code>.
     *
     * @param   value   a <code>double</code> precision floating-point number.
     * @return the bits that represent the floating-point number.
     * @since 1.3
     */
    public static native long doubleToRawLongBits(double value);
 

Достаточно простого приведения:

 double d = 0.5;

const unsigned char * buf = reinterpret_cast<const unsigned char *>(amp;d);

for (unsigned int i = 0; i != sizeof(double);   i)
  std::printf("The byte at position %u is 0xX.n", i, buf[i]);
 

Где находятся знаковый бит и биты экспоненты, зависит от вашей платформы и порядкового номера. Если ваши значения с плавающей запятой равны IEE754, если знак и показатель находятся впереди и если CHAR_BIT == 8 , вы можете попробовать это:

 const bool sign = buf[0] amp; 0x80;
const int exponent = ((buf[0] amp; 0x7F) << 4)   (buf[1] >> 4) - 1023;
 

(В C, скажем (const unsigned char *)(amp;d) , для приведения.)

Обновление: чтобы создать целое число с теми же битами, вы должны сначала создать целое число, а затем скопировать:

 unsigned long long int u;
unsigned char * pu = reinterpret_cast<unsigned char *>(amp;u);
std::copy(buf, buf   sizeof(double), pu);
 

Для этого вы должны иметь в виду несколько вещей: размер целого числа должен быть достаточным (статическое утверждение для sizeof(double) <= sizeof(unsigned long long int) должно сделать трюк), и если целое число на самом деле больше, то вы копируете только его части. Я уверен, что вы поймете это, хотя 🙂 (Вы могли бы использовать некоторую магию шаблона для создания целого числа правильного размера, если вы действительно хотите.)

 #include <stdint.h>

static inline uint64_t doubleToRawBits(double x) {
    uint64_t bits;
    memcpy(amp;bits, amp;x, sizeof bits);
    return bits;
}
 

Мне нравятся объединения для таких вещей.

 union double_and_buffer {
    double d;
    unsigned char byte_buff[ sizeof(double) ];
} dab;

dab.d = 1.0;
for ( int i = 0; i < sizeof(dab.byte_buff);   i )
{
    cout << hex byte_buff[ i ];
}
 

Я думаю, это делает более понятным, что вы делаете, и позволяет компилятору выполнять всю математику.