C: преобразовать действительное число в 64-битный двоичный файл с плавающей запятой

следующий код используется для определения внутреннего представления числа с плавающей запятой в соответствии с нотацией IEEE754. Этот код сделан в Turbo C++ ide, но вы можете легко преобразовать его в универсальный ide.

#include<conio.h>
#include<stdio.h>

void decimal_to_binary(unsigned char);

union u
{
    float f;
    char c;
};

int main()
{
    int i;
    char*ptr;
    union u a;

    clrscr();
    printf("ENTER THE FLOATING POINT NUMBER : \n");
    scanf("%f",&a.f);

    ptr=&a.c+sizeof(float);

    for(i=0;i<sizeof(float);i++)
    {
        ptr--;
        decimal_to_binary(*ptr);
    }

    getch();
    return 0;
}

void decimal_to_binary(unsigned char n)
{
    int arr[8];
    int i;
    //printf("n = %u  ",n);

    for(i=7;i>=0;i--)
    {
        if(n%2==0)
            arr[i]=0;
        else
            arr[i]=1;
        n/=2;
    }

    for(i=0;i<8;i++)
        printf("%d",arr[i]);
    printf(" ");
}

Для получения дополнительной информации посетите страницу Нажмите здесь!

Чтобы правильно округлить все возможные десятичные представления до ближайшего double, вам нужны большие целые числа. Использование только базовых целочисленных типов из C оставит вас для повторной реализации арифметики больших целых чисел. Возможен каждый из этих двух подходов, дополнительная информация о каждом из них приведена ниже:

1. Для первого подхода вам понадобится большая целочисленная библиотека: GMP — это хорошо. Вооружившись такой большой целочисленной библиотекой, вы обрабатываете ввод, например 123.456E78, как целое число 123456 * 10⁷⁵ и начинаете задаваться вопросом, какие значения M в [2⁵³… 2⁵⁴) и P в [-1022 … 1023] делают (M / 2⁵³) * 2^P ближайшим к этому числу. На этот вопрос можно ответить с помощью операций с большими целыми числами, следуя шагам, описанным в этот пост в блоге (резюме: сначала определите P. Затем используйте деление для вычисления M). Полная реализация должна учитывать субнормальные числа и бесконечности (inf — правильный результат для любого десятичного представления числа, у которого показатель степени больше +1023).

2. Второй подход, если вы не хотите включать или реализовывать полную библиотеку больших целых чисел общего назначения, по-прежнему требует реализации нескольких основных операций над массивами целых чисел C, представляющих большие числа. Функция decfloat() в этой реализации представляет большие числа в базе 10⁹, поскольку это упрощает преобразование исходного десятичного представления во внутреннее представление в виде массива x из uint32_t.

Ниже приведено основное преобразование. Достаточно, чтобы начать ОП.

«Целая часть действительного числа» OP -> int слишком ограничивает. Лучше просто преобразовать всю строку в большое целое число, например uintmax_t. Обратите внимание на десятичную точку '.' и учтите переполнение при сканировании.

Этот код не обрабатывает экспоненты и отрицательные числа. Он может быть отключен в последнем бите или около того из-за ограниченного целого числа ui или последнего num = ui * pow10(expo). Он обрабатывает большинство случаев переполнения.

#include <inttypes.h>

double my_atof(const char *src) {
  uintmax_t ui = 0;
  int dp = '.';
  size_t dpi;
  size_t i = 0;
  size_t toobig = 0;
  int ch;
  for (i = 0; (ch = (unsigned char) src[i]) != '\0'; i++) {
    if (ch == dp) {
      dp = '\0';  // only get 1 dp
      dpi = i;
      continue;
    }
    if (!isdigit(ch)) {
      break; // illegal character
    }
    ch -= '0';
    // detect overflow
    if (toobig || 
        (ui >= UINTMAX_MAX / 10 && 
        (ui > UINTMAX_MAX / 10 || ch > UINTMAX_MAX % 10))) {
      toobig++;
      continue;
    }
    ui = ui * 10 + ch;
  }
  intmax_t expo = toobig;
  if (dp == '\0') {
    expo -= i - dpi - 1;
  }

  double num;
  if (expo < 0) {
    // slightly more precise than: num = ui * pow10(expo);
    num = ui / pow10(-expo);
  } else {
    num = ui * pow10(expo);
  }
  return num;
}

Хитрость заключается в том, чтобы рассматривать значение как целое число, поэтому читайте 547.4242 как unsigned long long (то есть 64-битный или более), то есть 5474242, подсчитывая количество цифр после «.», в данном случае 4. Теперь вы иметь значение, которое на 10 ^ 4 больше, чем должно быть. Итак, вы плаваете 5474242 (как двойное или длинное двойное) и делите на 10 ^ 4.

Преобразование десятичного числа в двоичное обманчиво просто. Когда у вас больше битов, чем вмещает число с плавающей запятой, оно должно округляться. Гораздо интереснее, когда у вас больше цифр, чем вмещает 64-битное целое число, учитывая, что конечные нули имеют особое значение, и вам нужно решить, округлять или нет (и какое округление происходит, когда вы плаваете). Тогда есть дело с E+/-99. Затем, когда вы выполняете окончательное деление (или умножение) на 10^n, у вас есть (а) другое потенциальное округление и (б) проблема, заключающаяся в том, что большие 10^n не точно представлены в вашем плавающем точка - что является еще одним источником ошибки. (А для форм E+/-99 вам может понадобиться до и чуть больше 10^300 для последнего шага.)

Наслаждаться !