преобразуйте двойное значение в двоичное значение

Ну, вы не указали платформу или тип двоичного значения, которое вас интересует, но в .NET есть BitConverter.DoubleToInt64Bits , который позволяет вам получить 754 бита IEEE, составляющие ценить очень легко.

В Java есть Double.doubleToLongBits , который делает то же самое.

Обратите внимание, что если у вас есть такое значение, как «125252525235558554452221545332224587265», то у вас больше информации, чем можно точно сохранить с помощью double.

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

Всегда используйте теги заголовков. Подсказка в названии:)

Если вы не хотите, чтобы они были полужирными, измените их стиль с CSS. Например,

HTML:

<h3 class="list-heading">heading</h3>

<ul> 
    <li>list item </li>
    <li>list item </li>
    <li>list item </li>
</ul>

CSS

.list-heading {
    font-weight: normal;
}

В HTML5 можно более четко связать заголовок и список с помощью элемента < section > . ( < раздел > не работает должным образом в IE 8 и ранее без какого-либо JavaScript.)

<section>
    <h1>heading</h1>

    <ul>
        <li>list item </li>
        <li>list item </li>
        <li>list item </li>
    </ul>
</section>

Можно сделать нечто подобное в HTML- 4:

<div class="list-with-heading">
    <h3>Heading</h3>

    <ul>
        <li>list item </li>
        <li>list item </li>
        <li>list item </li>
    </ul>
</div>

Тогда стиль таким образом:

.list-with-heading h3 {
    font-weight: normal;
}

В C, вы можете сделать это, например, этот путь, который является классическим использованием конструкции union :

int i;
union {
 double x;
 unsigned char byte[sizeof (double)];
} converter;

converter.x = 5.5555555555556e18;

for(i = 0; i < sizeof converter.byte; i++)
  printf("%02x", converter.byte[i]);

Если поместить его в основной () и запустить, он может напечатать что-то подобное:

~/src> gcc -o floatbits floatbits.c
~/src> ./floatbits
ba b5 f6 15 53 46 d3 43

Обратите внимание, что это, конечно, зависит от платформы в своей зависимости . Приведенное выше относится к системе Linux, работающей на процессоре Sempron, т.е. это мало endian.

Если вы имеете в виду, что хотите сделать это самостоятельно, то это не вопрос программирования.

Если вы хотите заставить компьютер делать это, самый простой способ - использовать процедуру ввода с плавающей запятой, а затем отобразить результат в шестнадцатеричной форме. В C ++:

double f = atof ("5.5555555555556E18");
unsigned char  *b = (unsigned char *) &f;
for (int j = 0; j < 8;  ++j)
    printf (" %02x", b [j]);

Вы задаете неправильный вопрос.

Перегрузки, на которые вы указываете, должны быть оптимизированы для прямого вызова параметров. То есть компилятор вложит переменные в arg_0, arg_1, arg_2, arg_3, возможно иметь больше, чем это, но IL имеет только эти в качестве быстрого доступа. Остальное в любом случае проходит через стек и, следовательно, не намного эффективнее, чем вызов функции param type.

Для вызова функции param type он фактически создает массив за сценами и отправляет его функции как arg_1 (в данном случае, где arg_0 поглощается последовательностью).

См. API здесь

Сначала извлеките объекты с помощью

[dict objectForKey:@"key"];

Позже их можно вернуть с помощью:

- (void)setObject:(id)anObject forKey:(id)aKey
- (void)setValue:(id)value forKey:(NSString *)key

Двойное значение уже является двоичным значением. Это просто вопрос представительства, которое вы хотите иметь. В языке программирования, когда вы называете его двойным, то язык, который вы используете, интерпретирует его одним способом. Если один и тот же фрагмент памяти называется int, то это не тот же номер.

Так что это зависит от того, что вы действительно хотите... Если нужно записать его на диск или в сеть, то нужно подумать о BigEndian/LittleEndian.

Для этих огромных чисел (которые нельзя точно представить с помощью двойника) вам нужно использовать какой-то специализированный класс для хранения необходимой информации.

C # предоставляет класс Decimal:

Тип значения Decimal представляет десятичные числа в диапазоне от положительных 79,228,162,514,264,337,593,543,950,335 до отрицательных 79,228,162,514,264,337,593,543,950,335. Тип значения Decimal подходит для финансовых расчетов, требующих большого количества значащих целых и дробных цифр и отсутствия ошибок округления. Тип Decimal не исключает необходимости округления. Скорее, он сводит к минимуму ошибки из-за округления. Например, следующий код дает результат 0,99999999999999999999999999, а не 1.

Если вам нужна более высокая точность, чем эта, я думаю, вам нужно создать свой собственный класс. Здесь есть один для ints: http://sourceforge.net/projects/cpp-bigint/ , хотя, похоже, он предназначен для C ++.