Convertir un float de 4 u_int8_t

J'ai un float variable que j'ai besoin d'envoyer par le biais d'un protocole can. Pour ce faire, ce flotteur de 32 bits doit être coupé dans 4 uint8_t variables.

Je n'ai absolument aucune idée de comment le faire. J'ai d'abord été pensée de convertir le float en int mais quelques réponses que j'ai trouvé sur Internet qui utilisent la fonte ou de l'union ne semble pas fonctionner.

Voici un exemple simple de ce que je suis en train de faire :

float f;
uint8_t ut1,ut2,ut3,ut4;

//8 first bits of f into ut1
//8 second bits of f in ut2
...

//Then I can send the uint8_t through CAN
...

Grâce.

Ne voulez-vous pas uint8_t[4] au lieu de 4 * uint8_t variables?
Aussi montrer le code que vous utilisez et une certaine idée de la méthode que vous appelez (c'est à dire sa sémantique).
J'ai besoin de 4 différents variable distincte si possible , mais un onglet peut être ok. Je n'ai pas le code de bonne à vous montrer ... seul test avec des acteurs et de l'union
double de stackoverflow.com/questions/21005845/how-to-get-float-bytes stackoverflow.com/questions/18270974/... stackoverflow.com/questions/3991478/... stackoverflow.com/questions/7157301/... ...

OriginalL'auteur Evans Belloeil | 2014-08-19

c++floating-point-conversion qt uint8t

7

Normalement, vous faites ceci en jetant le flotteur à un tableau de u_int8_t.

En C, vous pouvez le faire comme ceci:
```
uint8_t *array;
array = (unit8_t*)(&f);
```
en C++ utilise le reinterpret_cast
```
uint8_t *array;
array = reinterpret_cast<uint8_t*>(&f);
```
Puis tableau[0], ..., tableau[3] sont vos octets.

Que diriez-endianess ?
Il peut être endianess, mais c'est vrai, cependant, nous avons divisé le flotteur en octets. Je dirais que c'est une question distincte. Quel que soit le protocole spécifie les OP devront respecter.

OriginalL'auteur dohashi
2

D'abord vous devriez noter que la norme n'impose aucune restriction de taille sur float. Il est possible qu'un float ne rentre pas dans les quatre octets sur certains imaginables architecture (bien que je ne suis pas au courant de tout). Vous devriez au moins (static_)affirment qu'il fit avant de tenter quoi que ce soit.

Alors je pense que le plus simple est d'affirmer que CHAR_BIT est 8, et l'utilisation de l'juridique de l'aliasing à unsigned char* avec reinterpret_cast:
```
static_assert(sizeof(float) == 4);
float f = 0; //whatever value
unsigned char* float_as_char = reinterpret_cast<unsigned char*>(&f);
```
Cet ignore totalement les endian question, cependant, de sorte que peut-être ce que vous voulez vraiment est de faire une copie des octets de sorte que vous pouvez corriger cela:
```
static_assert(sizeof(float) == 4);
float f = 0; //whatever value
uint8_t bytes[4];
std::memcpy(bytes, &f);
//Fix up the order of the bytes in "bytes" now.
```
OriginalL'auteur Mark B
1

Vous pouvez faire cette opération illégale:
```
float f = someFloatValue;
uint8_t* i = reinterpret_cast<uint8_t*>(&f);
```
Bien que cela fonctionne la plupart du temps, il n'est pas pris en charge par le c++ standard et les compilateurs peuvent générer du code avec un comportement indéterminé.

Une autre solution est d'utiliser des syndicats:
```
union{
    float f;
    uint8_t i[4];
}
f = someFloatValue;
//now i's contain the bit pattern of f
```
Il est difficile de savoir si tous les compilateurs de produire des résultats uniformes, mais il semble plus sûre que la première approche.

Vous pouvez également emballer la valeur de f dans un entier de 32 bits. Ceci, cependant, peut entraîner la perte d'un peu de précision, mais en fonction de la précision avec laquelle vous voulez garder f, ce serait la meilleure solution.

J'ai posté une union de réponse juste avant, mais ensuite j'ai réalisé que c'est un comportement indéterminé: stackoverflow.com/questions/17273320/...
Techniquement, la lecture à partir d'un syndicat différent de la dernière écriture est un comportement indéfini. Cependant, tous les principaux compilateurs C++ à donner la garantie que cela fonctionnera correctement. C'est toujours la bonne réponse, comme il n'existe pas de standard conforme façon de le réaliser autrement.
Ah, merci pour la restauration de ma foi dans le union.

OriginalL'auteur rashmatash
1

Voici une approche de l'union qui donne des noms différents pour entier pièces au lieu d'un tableau:
```
union {
    float f;
    struct {
        uint8_t ut1, ut2, ut3, ut4;
    } bytes;
} value;
value.f = 1.f;
uint8_t first = value.bytes.ut1;
```
Au départ, j'étais inquiète de ce que cette utilisation de union n'est pas strictement juridique selon la norme: C++ comportement Indéfini avec les syndicats mais ComicSansMS de l'argument dans un commentaire à rashmatash la réponse est convaincante.

OriginalL'auteur eerorika

Vous devez vous connecter pour publier un commentaire.