Вопросы Теги

Как я отображаю двоичное представление плавания или дважды?

В основном это то, как генерические средства реализуются на Java через компиляцию. Скомпилированный общий код на самом деле просто использует java.lang.Object везде, где вы говорите о T (или каком-либо другом параметре типа), - и есть некоторые метаданные, чтобы сообщить компилятору, что он действительно является общим типом.

Когда вы компилируете какой-либо код против общего типа или метода, компилятор разрабатывает то, что вы действительно имеете в виду (то есть, что такое аргумент типа для T) и проверяет время компиляции , которое вы делаете правильные вещи, но испущенный код снова просто говорит в терминах java.lang.Object - компилятор при необходимости создает дополнительные приведения. Во время выполнения List и List точно совпадают; Дополнительная информация о типе была удалена компилятором.

Сравните это, скажем, с C #, где информация сохраняется во время выполнения, позволяя коду содержать выражения, такие как typeof(T), что эквивалентно T.class - за исключением того, что последнее недействительно. (Есть дополнительные различия между .NET-генераторами и Java-дженериками, заметьте.) Стирание типа является источником многих «нечетных» предупреждений / сообщений об ошибках при работе с генериками Java.

Другие ресурсы:

38
задан Bill the Lizard 16 January 2009 в 19:05
поделиться

6 ответов

C/C++ легок. 

union ufloat {
  float f;
  unsigned u;
};

ufloat u1;
u1.f = 0.3f;

Тогда Вы просто производите u1.u. Можно адаптироваться эта реализация .

Удваивается столь же легкий. 

union udouble {
  double d;
  unsigned long u;
}

, потому что удваивается, 64 бита.

Java немного легче: используйте Float.floatToRawIntBits () объединенный с Integer.toBinaryString () и Double.doubleToRawLongBits, объединенный с Long.toBinaryString () .

31
ответ дан Serge 10 October 2019 в 07:03
поделиться

Java: поиск Google находит эту ссылку на форумы Sun

конкретно (я не попробовал это сам) 

long binary = Double.doubleToLongBits(3.14159);
String strBinary = Long.toBinaryString(binary);
7
ответ дан Pang 10 October 2019 в 07:03
поделиться

В C++ можно показать двоичное представление это таким образом: 

template <class T>
std::bitset<sizeof(T)*8> binary_representation(const T& f)
{
   typedef unsigned long TempType;
   assert(sizeof(T)<=sizeof(TempType));
   return std::bitset<sizeof(T)*8>(*(reinterpret_cast<const TempType*>(&f)));
}

предел здесь должен то, что bitset, более длинный параметр является неподписанным длинным, таким образом, это обрабатывает для плавания, можно использовать что-то еще, чем bitset и расширение, которые утверждают.

BTW, cletus предложение перестал работать в том смысле, что Вам нужно "unsingned долго долго" для покрытия двойного, так или иначе Вам нужно что-то, что показывает двоичный файл (1 или 0) представление.

0
ответ дан Gaetano Mendola 10 October 2019 в 07:03
поделиться

Хорошо оба, Плавание и Двойной класс (в Java) имеют toHexString ('плавание') метод так в значительной степени, это сделало бы для шестнадцатеричного преобразования 

Double.toHexString(42344);
Float.toHexString(42344);

Легкий как круг!

3
ответ дан Gareth 10 October 2019 в 07:03
поделиться

В.NET (включая C#), Вы имеете BitConverter, который принимает много типов, предоставляя доступ к необработанному двоичному файлу; получить шестнадцатеричное число, ToString("x2") - наиболее распространенная опция (возможно, обернутый в служебный метод): 

    byte[] raw = BitConverter.GetBytes(123.45);
    StringBuilder sb = new StringBuilder(raw.Length * 2);
    foreach (byte b in raw)
    {
        sb.Append(b.ToString("x2"));
    }
    Console.WriteLine(sb);

Странно, базируйтесь 64, имеет преобразование с 1 строкой (Convert.ToBase64String), но основа 16 прилагает больше усилий. Если Вы не ссылаетесь на Microsoft. VisualBasic, в этом случае: 

long tmp = BitConverter.DoubleToInt64Bits(123.45);
string hex = Microsoft.VisualBasic.Conversion.Hex(tmp);
6
ответ дан Marc Gravell 10 October 2019 в 07:03
поделиться

Я сделал это этот путь: 

/*
@(#)File:           $RCSfile: dumpdblflt.c,v $
@(#)Version:        $Revision: 1.1 $
@(#)Last changed:   $Date: 2007/09/05 22:23:33 $
@(#)Purpose:        Print C double and float data in bytes etc.
@(#)Author:         J Leffler
@(#)Copyright:      (C) JLSS 2007
@(#)Product:        :PRODUCT:
*/

/*TABSTOP=4*/

#include <stdio.h>
#include "imageprt.h"

#ifndef lint
/* Prevent over-aggressive optimizers from eliminating ID string */
extern const char jlss_id_dumpdblflt_c[];
const char jlss_id_dumpdblflt_c[] = "@(#)$Id: dumpdblflt.c,v 1.1 2007/09/05 22:23:33 jleffler Exp $";
#endif /* lint */

union u_double
{
    double  dbl;
    char    data[sizeof(double)];
};

union u_float
{
    float   flt;
    char    data[sizeof(float)];
};

static void dump_float(union u_float f)
{
    int exp;
    long mant;

    printf("32-bit float: sign: %d, ", (f.data[0] & 0x80) >> 7);
    exp = ((f.data[0] & 0x7F) << 1) | ((f.data[1] & 0x80) >> 7);
    printf("expt: %4d (unbiassed %5d), ", exp, exp - 127);
    mant = ((((f.data[1] & 0x7F) << 8) | (f.data[2] & 0xFF)) << 8) | (f.data[3] & 0xFF);
    printf("mant: %16ld (0x%06lX)\n", mant, mant);
}

static void dump_double(union u_double d)
{
    int exp;
    long long mant;

    printf("64-bit float: sign: %d, ", (d.data[0] & 0x80) >> 7);
    exp = ((d.data[0] & 0x7F) << 4) | ((d.data[1] & 0xF0) >> 4);
    printf("expt: %4d (unbiassed %5d), ", exp, exp - 1023);
    mant = ((((d.data[1] & 0x0F) << 8) | (d.data[2] & 0xFF)) << 8) |
              (d.data[3] & 0xFF);
    mant = (mant << 32) | ((((((d.data[4] & 0xFF) << 8) |
              (d.data[5] & 0xFF)) << 8) | (d.data[6] & 0xFF)) << 8) |
              (d.data[7] & 0xFF);
    printf("mant: %16lld (0x%013llX)\n", mant, mant);
}

static void print_value(double v)
{
    union u_double d;
    union u_float  f;

    f.flt = v;
    d.dbl = v;

    printf("SPARC: float/double of %g\n", v);
    image_print(stdout, 0, f.data, sizeof(f.data));
    image_print(stdout, 0, d.data, sizeof(d.data));
    dump_float(f);
    dump_double(d);
}


int main(void)
{
    print_value(+1.0);
    print_value(+2.0);
    print_value(+3.0);
    print_value( 0.0);
    print_value(-3.0);
    print_value(+3.1415926535897932);
    print_value(+1e126);
    return(0);
}

Работа SUN UltraSPARC, я добрался: 

SPARC: float/double of 1
0x0000: 3F 80 00 00                                       ?...
0x0000: 3F F0 00 00 00 00 00 00                           ?.......
32-bit float: sign: 0, expt:  127 (unbiassed     0), mant:                0 (0x000000)
64-bit float: sign: 0, expt: 1023 (unbiassed     0), mant:                0 (0x0000000000000)
SPARC: float/double of 2
0x0000: 40 00 00 00                                       @...
0x0000: 40 00 00 00 00 00 00 00                           @.......
32-bit float: sign: 0, expt:  128 (unbiassed     1), mant:                0 (0x000000)
64-bit float: sign: 0, expt: 1024 (unbiassed     1), mant:                0 (0x0000000000000)
SPARC: float/double of 3
0x0000: 40 40 00 00                                       @@..
0x0000: 40 08 00 00 00 00 00 00                           @.......
32-bit float: sign: 0, expt:  128 (unbiassed     1), mant:          4194304 (0x400000)
64-bit float: sign: 0, expt: 1024 (unbiassed     1), mant: 2251799813685248 (0x8000000000000)
SPARC: float/double of 0
0x0000: 00 00 00 00                                       ....
0x0000: 00 00 00 00 00 00 00 00                           ........
32-bit float: sign: 0, expt:    0 (unbiassed  -127), mant:                0 (0x000000)
64-bit float: sign: 0, expt:    0 (unbiassed -1023), mant:                0 (0x0000000000000)
SPARC: float/double of -3
0x0000: C0 40 00 00                                       .@..
0x0000: C0 08 00 00 00 00 00 00                           ........
32-bit float: sign: 1, expt:  128 (unbiassed     1), mant:          4194304 (0x400000)
64-bit float: sign: 1, expt: 1024 (unbiassed     1), mant: 2251799813685248 (0x8000000000000)
SPARC: float/double of 3.14159
0x0000: 40 49 0F DB                                       @I..
0x0000: 40 09 21 FB 54 44 2D 18                           @.!.TD-.
32-bit float: sign: 0, expt:  128 (unbiassed     1), mant:          4788187 (0x490FDB)
64-bit float: sign: 0, expt: 1024 (unbiassed     1), mant: 2570638124657944 (0x921FB54442D18)
SPARC: float/double of 1e+126
0x0000: 7F 80 00 00                                       ....
0x0000: 5A 17 A2 EC C4 14 A0 3F                           Z......?
32-bit float: sign: 0, expt:  255 (unbiassed   128), mant:                0 (0x000000)
64-bit float: sign: 0, expt: 1441 (unbiassed   418), mant:      -1005281217 (0xFFFFFFFFC414A03F)
4
ответ дан Jonathan Leffler 10 October 2019 в 07:03
поделиться
Другие вопросы по тегам:

Похожие вопросы: