La construction d'un 32-bit à virgule flottante de son composite 4 octets

Je suis en train de construire un 32-bit à virgule flottante de son composite 4 octets. Est-il mieux (ou plus portable) façon de le faire que avec la méthode suivante?

#include <iostream>

typedef unsigned char uchar;

float bytesToFloat(uchar b0, uchar b1, uchar b2, uchar b3)
{
    float output;

    *((uchar*)(&output) + 3) = b0;
    *((uchar*)(&output) + 2) = b1;
    *((uchar*)(&output) + 1) = b2;
    *((uchar*)(&output) + 0) = b3;

    return output;
}

int main()
{
    std::cout << bytesToFloat(0x3e, 0xaa, 0xaa, 0xab) << std::endl; //1.0 /3.0
    std::cout << bytesToFloat(0x7f, 0x7f, 0xff, 0xff) << std::endl; //3.4028234 × 10^38  (max single precision)

    return 0;
}
  • Considérant que c'était ma première question sur Stack Overflow, je suis ravie à l'différentes réponses. Je remercie tout le monde pour leur contribution.
InformationsquelleAutor Madgeek | 2010-10-21
  1. 29

    Vous pouvez utiliser un memcpy (Résultat)

    float f;
uchar b[] = {b3, b2, b1, b0};
memcpy(&f, &b, sizeof(f));
return f;

    ou d'un syndicat* (Résultat)

    union {
  float f;
  uchar b[4];
} u;
u.b[3] = b0;
u.b[2] = b1;
u.b[1] = b2;
u.b[0] = b3;
return u.f;

    Mais ce n'est plus portable que votre code, car il n'existe aucune garantie que la plate-forme est en little-endian ou la float est l'aide de l'IEEE binary32 ou même sizeof(float) == 4.

    (Note*: Comme expliqué par @James, il n'est techniquement pas autorisé dans la norme C++ §[classe.l'union]/1) pour accéder à la membre de l'union u.f.)

    • Pour résoudre le sizeof(float) problème, vous pouvez simplement déclarer b membre uchar b[sizeof(float)];.
    • Droit, mais alors l'entrée doit être modifiée.
    • L'union méthode aboutit à un comportement indéfini.
    InformationsquelleAutor kennytm
  2. 15

    Les fonctions suivantes pack/unpack octets représentant un virgule flottante simple précision de la valeur à partir d'un tampon dans l'ordre des octets de réseau. Seule la méthode pack doit prendre endianness en compte puisque la méthode de décompression explicitement construit la valeur de 32 bits de chaque octet par le décalage de bits d'eux le montant approprié et puis OU-ing ensemble. Ces fonctions ne sont valables que pour le C/C++ implémentations de ce magasin, d'un flotteur en 32 bits. Cela est vrai pour IEEE 754-1985 virgule flottante implémentations.

    //unpack method for retrieving data in network byte,
//  big endian, order (MSB first)
//increments index i by the number of bytes unpacked
//usage:
//  int i = 0;
//  float x = unpackFloat(&buffer[i], &i);
//  float y = unpackFloat(&buffer[i], &i);
//  float z = unpackFloat(&buffer[i], &i);
float unpackFloat(const void *buf, int *i) {
const unsigned char *b = (const unsigned char *)buf;
uint32_t temp = 0;
*i += 4;
temp = ((b[0] << 24) |
(b[1] << 16) |
(b[2] <<  8) |
b[3]);
return *((float *) &temp);
}
//pack method for storing data in network,
//  big endian, byte order (MSB first)
//returns number of bytes packed
//usage:
//  float x, y, z;
//  int i = 0;
//  i += packFloat(&buffer[i], x);
//  i += packFloat(&buffer[i], y);
//  i += packFloat(&buffer[i], z);
int packFloat(void *buf, float x) {
unsigned char *b = (unsigned char *)buf;
unsigned char *p = (unsigned char *) &x;
#if defined (_M_IX86) || (defined (CPU_FAMILY) && (CPU_FAMILY == I80X86))
b[0] = p[3];
b[1] = p[2];
b[2] = p[1];
b[3] = p[0];
#else
b[0] = p[0];
b[1] = p[1];
b[2] = p[2];
b[3] = p[3];
#endif
return 4;
}
    • Je pense qu'il y a une erreur dans la ligne de code: retour *((float *) temp); Il devrait être: return *((float *) &temp);
    • Je suis assez sûr que c'est un comportement indéterminé en C++ en raison de la rigidité de l'aliasing règles.
    InformationsquelleAutor jholl
  3. 14

    Vous pouvez utiliser std::copy:

    float bytesToFloat(uchar b0, uchar b1, uchar b2, uchar b3) 
{ 
uchar byte_array[] = { b3, b2, b1, b0 };
float result;
std::copy(reinterpret_cast<const char*>(&byte_array[0]),
reinterpret_cast<const char*>(&byte_array[4]),
reinterpret_cast<char*>(&result));
return result;
}

    Cela évite l'union hack, ce qui n'est pas techniquement autorisé par la langue. Il évite aussi les plus couramment utilisés reinterpret_cast<float*>(byte_array), ce qui viole la stricte aliasing règles (il est permis de réinterpréter n'importe quel objet comme un tableau de char, de sorte que le reinterpret_casts dans cette solution ne violent pas la stricte aliasing règles).

    Il repose toujours sur float de quatre octets en largeur et s'appuie sur quatre octets être valide d'un nombre à virgule flottante de la mise en œuvre du format à virgule flottante, mais vous devez prendre ces hypothèses ou vous devez écrire particulières de manipulation de code pour faire la conversion.

    • Ce n'est toujours pas de portable, pas vrai? Je suis juste curieux...
    • Non; il repose toujours sur sizeof(float) == 4 et ne prennent pas l'endianness en considération. Il évite tout reinterpret_cast<float*>(some_uchar_array) et l'union hack.
    • Je suis assez certain que reinterpret_cast<float*>(byte_array) doit être autorisé que si l'byte_array (1) est correctement aligné et (2) contient un flotteur. Je pense que oui parce que sinon il serait impossible de memcpy un float à l'autre float (depuis memcpy écrit sur un tableau d'octets), et encore une float est l'archétype du type POD.
    • Mais memcpy ne pas réinterpréter un tableau d'octets comme un float; elle réinterprète un flotteur comme un tableau d'octets.
    • C'est en effet pas memcpy lui-même; qui de toute évidence ne fonctionne que sur des tableaux d'octets. C'est la garantie que vous pouvez utiliser la sortie tableau d'octets comme un float.
    InformationsquelleAutor James McNellis
  4. 4

    Il n'y a aucun moyen de le faire ce portable, depuis différentes plateformes pouvez utiliser:

    • différents octets de commande (big endian vs little endian)
    • des représentations différentes pour les valeurs à virgule flottante (voir http://en.wikipedia.org/wiki/IEEE_754-1985 pour un exemple)
    • des tailles différentes pour les valeurs à virgule flottante

    Je me demande aussi où vous pouvez obtenir ces 4 octets à partir d'?

    Si je suppose que vous obtenez à partir d'un autre système, et vous pouvez garantir que les deux systèmes utilisent exactement la même méthode pour stocker des valeurs en virgule flottante dans la mémoire, vous pouvez utiliser de l'union truc. Sinon, ton code est presque assuré d'être non-portable.

    InformationsquelleAutor Patrick
  5. 3

    Si vous voulez un portable de façon à ce faire, vous aurez à écrire un peu de code pour détecter l'endianess du système.

    float bytesToFloatA(uchar b0, uchar b1, uchar b2, uchar b3)
{
float output;
*((uchar*)(&output) + 3) = b0;
*((uchar*)(&output) + 2) = b1;
*((uchar*)(&output) + 1) = b2;
*((uchar*)(&output) + 0) = b3;
return output;
}
float bytesToFloatB(uchar b0, uchar b1, uchar b2, uchar b3)
{
float output;
*((uchar*)(&output) + 3) = b3;
*((uchar*)(&output) + 2) = b2;
*((uchar*)(&output) + 1) = b1;
*((uchar*)(&output) + 0) = b0;
return output;
}
float (*correctFunction)(uchar b0, uchar b1, uchar b2, uchar b3) = bytesToFloatA;
if ((*correctFunction)(0x3e, 0xaa, 0xaa, 0xab) != 1.f/3.f) //horrifying, I know
{
correctFunction = bytesToFloatB;
}
    • Qui ne sera pas égale dans tous les endians parce que 1./3. est un double, pas un float. Vous devriez utiliser quelque chose comme 1.0f/3.
    InformationsquelleAutor JoshD