Как получить байты с плавающей точкой?

Question

Я использую HIDAPI для отправки некоторых данных на USB-устройство. Эти данные могут быть отправлены только в виде байтового массива, и мне нужно отправить некоторые числа с плавающей запятой в этот массив данных. Я знаю, что поплавки имеют 4 байта, так что я думал, что это может работать:

float f = 0.6; 
char data[4]; 

data[0] = (int) f >> 24; 
data[1] = (int) f >> 16; 
data[2] = (int) f >> 8; 
data[3] = (int) f; 

А потом все, что я должен был сделать это:

g = (float)((data[0] << 24) | (data[1] << 16) | (data[2] << 8) | (data[3])); 

Но тестирование это показывает мне, что линии, как data[0] = (int) f >> 24; возвращается всегда 0. Что не так с моим кодом и как я могу сделать это правильно (т. Е. Разбить внутренние данные float в 4 символьных байта и перестроить один и тот же float позже)?

EDIT:

Я был в состоянии сделать это со следующими кодами:

float f = 0.1; 
unsigned char *pc; 
pc = (unsigned char*)&f; 

// 0.6 in float 
pc[0] = 0x9A; 
pc[1] = 0x99; 
pc[2] = 0x19; 
pc[3] = 0x3F; 

std::cout << f << std::endl; // will print 0.6 

и

*(unsigned int*)&f = (0x3F << 24) | (0x19 << 16) | (0x99 << 8) | (0x9A << 0); 

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

Answer 1

Вы можете сделать это следующим образом:

char data[sizeof(float)]; 


float f = 0.6f; 

memcpy(data, &f, sizeof f); // send data 


float g; 

memcpy(&g, data, sizeof g); // receive data 

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

---

Как справедливо отмечено в комментариях, вы не обязательно должны сделать дополнительные memcpy; вместо этого вы можете обрабатывать fнепосредственно как массив символов (любой подписи). Вы все равно должны сделать memcpy на принимающей стороне, хотя, так как вы можете не относиться к произвольному массиву символов как поплавок! Пример:

unsigned char const * const p = (unsigned char const *)&f; 
for (size_t i = 0; i != sizeof f; ++i) 
{ 
    printf("Byte %zu is %02X\n", i, p[i]); 
    send_over_network(p[i]); 
} 

Answer 2

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

unsigned char payload[4]; 
memcpy(payload, &f, 4); 

Answer 3

Возможно, было бы безопаснее объединить массив float и char. Поместите в поплавковый элемент, вытащите 4 (или любую длину) байтов.

Answer 4

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

hostPort writes char * "34.56\0" byte by byte 
client reads char * "34.56\0" 

затем преобразует плавать с функцией библиотеки atof или atof_l.

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

Если вы хотите получить более оптимизированный и креативный, первый байт - это длина, то экспонента, то каждый байт представляет собой 2 десятичных знака ...так что

34.56 будет char array[] = {4,-2,34,56}; что-то вроде этого было бы портативным ... Я бы просто попытался не передавать двоичные представления с плавающей точкой ... потому что он может быстро стать беспорядочным.

Answer 5

Язык C гарантирует, что любое значение любого типа¹ можно получить в виде массива байтов. Тип байтов: unsigned char. Вот низкоуровневый способ копирования float в массив байтов. sizeof(f) - количество байтов, используемых для хранения значения переменной f; вы также можете использовать sizeof(float) (вы можете передать sizeof переменное или более сложное выражение или его тип).

float f = 0.6; 
unsigned char data[sizeof(float)]; 
size_t i; 
for (i = 0; i < sizeof(float); i++) { 
    data[i] = (unsigned char*)f + i; 
} 

функции memcpy или memmove делать то, что (или оптимизированную версию этого).

float f = 0.6; 
unsigned char data[sizeof(float)]; 
memcpy(data, f, sizeof(f)); 

Вам даже не нужно делать эту копию. Вы можете напрямую передать указатель на float на функцию write-to-USB и указать, сколько байтов для копирования (sizeof(f)). Вам понадобится явное преобразование, если функция принимает аргумент указателя, отличный от void*.

int write_to_usb(unsigned char *ptr, size_t size); 
result = write_to_usb((unsigned char*)f, sizeof(f)) 

Обратите внимание, что это будет работать только в том случае, если устройство использует то же представление чисел с плавающей запятой, которое является общим, но не универсальным. Большинство машин используют IEEE floating point formats, но вам, возможно, придется переключать принцип.

---

Что касается того, что случилось с вашей попыткой: оператор >> оперирует целые числа. В выражении (int) f >> 24, f отливают до int; если вы написали f >> 24 без литых, f все равно будет автоматически преобразован в int. Преобразование значения с плавающей запятой в целое число аппроксимирует его, обрезая или округляя его (обычно в направлении 0, но правило зависит от платформы). 0,6, округленное до целого числа, равно 0 или 1, поэтому data[0] равно 0 или 1, а остальные - 0.

Вам необходимо действовать на байты объекта float, а не на его значение.

¹ _{Исключая функции, которые нельзя реально манипулировать с помощью C, но включая функции указателей, функции которых автоматически распадаются.}

Answer 6

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

#include <stdio.h> 

int main(void) 
{ 
    float x = 0x1.0p-3; /* 2^(-3) in hexa */ 

    union float_bytes { 
     float val; 
     unsigned char bytes[sizeof(float)]; 
    } data; 

    data.val = x; 
    for (int i = 0; i < sizeof(float); i++) 
      printf("Byte %d: %.2x\n", i, data.bytes[i]); 

    data.val *= 2; /* Doing something with the float value */ 
    x = data.val; /* Retrieving the float value   */ 
    printf("%.4f\n", data.val); 

    getchar(); 
} 

Как вы можете видеть, что это вообще не нужно использовать тетсру или указатели ...

union подход легко понять, стандартный и быстрый.

EDIT.

Я объясню, почему этот подход справедлив в C (C99).

• [5.2.4.2.1 (1)] Байт имеет CHAR_BIT битов (целую константу> = 8, в случаях почти 8).
• [6.2.6.1 (3)] Тип unsigned char использует все свои биты для представления значения объекта, являющегося неотрицательным целым, в чисто двоичном представлении. Это означает, что нет никаких битов заполнения или бит, используемых для любой другой экструзионной пурпуры. (То же самое не гарантируется для signed char или char типов).
• [6.2.6.1 (2)] Каждый небитообразный тип представляется в памяти как непрерывная последовательность байтов.
• [6.2.6.1 (4)] (Цитируется) «Значения, хранящиеся в объектах без битового поля любого другого типа объекта, состоят из битов n × CHAR_BIT, где n - размер объекта такого типа, в байтах. Значение может быть скопировано в объект типа unsigned char [n] (например, memcpy); [...] "
• [6.7.2.1 (14)] Указатель на объект структуры (в частности, союзы), соответствующим образом преобразованные, указывает на его первоначальный член. (Таким образом, в начале объединения нет байтов заполнения).
• [6,5 (7)] Содержание объекта можно получить с помощью символьного типа:

Объект должен иметь свою сохраненное значение доступны только именующее выражение, имеющее один из следующие типы:
- тип совместим с эффективным типом объекта,
- это Quali версия фи-е изд типа совместимы с эффективным типом объекта,
- это тип, который является знаком или без знака типа, соответствующего эффективная ре из объекта,
- типа, который является знаком или без знака типа, соответствующий QUALI версии фи эд из эффективного типа объекта,
- совокупность или объединения типа, который включает в себя один из вышеупомянутых типов среди его членов (в том числе, рекурсивно, amember о наличии subaggregate или содержащегося союза) или
- символьного типа

Дополнительная информация:

A discussion in google groups
Type-punning

РЕДАКТИРОВАТЬ 2

Еще одна деталь стандартной C99:

• [6.5.2.3 (3) Сноска 82]типа каламбурная разрешена:

Если член используется для доступа к содержимому объекта союза не то же самое, как член последней используемой для сохранить значение в объекте соответствующая часть объектного представления значения переинтерпретируется как представление объекта в новом типе, как описано в 6.2.6 (процесс, иногда называемый «тип punning»). Это может быть ловушечное представление.