преобразование массива байтов для удвоения - c

Почему бы просто не преобразовать массив в двойной указатель?

unsigned char input[16];

double* pd = (double*)input;

for (int i=0; i<sizeof(input)/sizeof(double); ++i)
    cout << pd[i];

если вам нужно исправить порядок байтов, перед преобразованием в массив типа double переверните массив символов с помощью STL reverse ().

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

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

1) Предполагая, что байтовый массив представляет собой буфер памяти, ссылающийся на целочисленное значение, вы сможете преобразовать свой байтовый массив в 128 -битовое целое число с помощью битового сдвига, а затем преобразовать полученное целое число в double . Не забывайте, что проблемы с порядком байтов могут возникнуть в зависимости от архитектуры процессора.

2) Предполагая, что байтовый массив представляет собой буфер памяти, который содержит 128-битное длинное двойное значение, и предполагая, что нет проблем с порядком байтов, вы должны иметь возможность записать значение из байтового массива в длинное двойное значение

union doubleOrByte {
    BYTE buffer[16];
    long double val;
} dOrb;
dOrb.val = 3.14159267;
long double newval = 0.0;

memcpy((void*)&newval, (void*)dOrb.buffer, sizeof(dOrb.buffer));

Вы пробовали std :: atof:

http://www.cplusplus.com/reference/clibrary/cstdlib/atof/

Вы пытаетесь преобразовать строковое представление числа в действительное число? В этом случае вам лучше всего подойдет C-стандарт atof.

Основываясь на приоритете операторов, правая часть

a = input[i] << 8*i;

оценивается перед преобразованием в двойное, поэтому вы сдвигаете input [i] на 8 * i битов, в которых хранится его результат - 32-битная временная переменная и, следовательно, происходит переполнение. Вы можете попробовать следующее:

a = (long long unsigned int)input[i] << 8*i;

Изменить: Не уверен, какой размер дубля в вашей системе, но в моем случае это 8 байтов, если это так для вас, а также вторая половина вашего ввода массив никогда не будет виден, поскольку сдвиг переполнит даже тип double.

Проблема в том, что на самом деле 32-битные переменные не могут быть сдвинуты более чем в 4 * 8 раз, т.е. ваш код работает только для 4 символов.

Что вы могли бы сделать, так это найти первый значимый символ и используйте закон Хорнера: a _n x ⁿ + a _n-1 ^n-1 + ... = ((.. . (a _n x + a _n-1 ) .x + a _n-2 ). x + ...) + a ₀ следующим образом:

char coefficients[16] = { 0, 0, ..., 14, 15 };
int exponent=15;
double result = 0.;

for(int exponent = 15; exp >= 0; --exp ) {
   result *= 256.; // instead of <<8.
   result += coefficients[ exponent ];
}