C de la Fonction de Convertir flotteur de tableau d'octets

Je suis en train de faire une fonction qui va accepter une variable de type float et de le convertir en un tableau d'octets. J'ai trouvé un bout de code qui fonctionne, mais souhaitez réutiliser dans une fonction si possible.

Je travaille aussi avec l'environnement Arduino, mais je comprends qu'il accepte la plupart des langage C.

Actuellement fonctionne:

float_variable = 1.11;
byte bytes_array[4];

*((float *)bytes_array) = float_variable;

Que puis-je modifier pour que cela fonctionne?

float float_test = 1.11;
byte bytes[4];

//Calling the function
float2Bytes(&bytes,float_test);

//Function
void float2Bytes(byte* bytes_temp[4],float float_variable){ 
     *(float*)bytes_temp = float_variable;  
}

Je ne suis pas familier avec les pointeurs et, mais j'ai lu que (float) est à l'aide de moulage ou de quelque chose?

Toute aide serait grandement appréciée!

Acclamations

*EDIT: RÉSOLU

Voici ma dernière fonction qui fonctionne dans l'Arduino pour toute personne qui le trouve. Il y a des solutions plus efficaces dans les réponses ci-dessous, cependant, je pense que c'est ok pour comprendre.

Fonction: convertit entrée variable de type float de tableau d'octets

void float2Bytes(float val,byte* bytes_array){
  //Create union of shared memory space
  union {
    float float_variable;
    byte temp_array[4];
  } u;
  //Overite bytes of union with float variable
  u.float_variable = val;
  //Assign bytes to input array
  memcpy(bytes_array, u.temp_array, 4);
}

Appel de la fonction

float float_example = 1.11;
byte bytes[4];

float2Bytes(float_example,&bytes[0]);

Merci pour l'aide de tous, j'ai beaucoup appris sur les pointeurs et le référencement dans les 20 dernières minutes, les Acclamations de Débordement de Pile!

OriginalL'auteur Ben Winding | 2014-06-25

19

Plus simple est de faire une union:
```
#include <stdio.h>

int main(void) {
  int ii;
  union {
    float a;
    unsigned char bytes[4];
  } thing;

  thing.a = 1.234;
  for (ii=0; ii<4; ii++) 
    printf ("byte %d is %02x\n", ii, thing.bytes[ii]);
  return 0;
}
```
De sortie:
```
byte 0 is b6
byte 1 is f3
byte 2 is 9d
byte 3 is 3f
```
Remarque - il n'y a aucune garantie quant à l'ordre des octets... cela dépend de votre architecture de la machine.

Pour obtenir votre fonction, ce faire:
```
void float2Bytes(byte* bytes_temp[4],float float_variable){ 
  union {
    float a;
    unsigned char bytes[4];
  } thing;
  thing.a = float_variable;
  memcpy(bytes_temp, thing.bytes, 4);
}
```
Ou vraiment hack:
```
void float2Bytes(byte* bytes_temp[4],float float_variable){ 
  memcpy(bytes_temp, (unsigned char*) (&float_variable), 4);
}
```
Remarque - dans les deux cas, j'ai assurez-vous de copier les données à l'emplacement donné que le paramètre d'entrée. Cela est essentiel, car les variables locales n'existent pas après votre retour (même si vous pourriez déclarer static, mais n'allons pas vous apprendre de mauvaises habitudes. Si la fonction est appelée de nouveau...)

Comment est ce programme de travail ?
l'union de deux éléments de données de quatre octets la taille qui rend ces deux occupent la même mémoire physique - donc, quand j'écris à thing.a j'écris dans le tableau d'octets. Vous trouverez que &thing.a == &thing.bytes ...
Ay, a obtenu. Je suis de rire de mon auto maintenant........! Mais vraiment bon. +1
Merci beaucoup! Je suis enfin de comprendre le concept de syndicats
J'ai été un peu surpris de votre question, et compte tenu de la qualité de vos contributions autour d'ici, en fait me suis interrogé ("ai-je fait quelque chose de vraiment stupide? S'ils n'ont pas compilé?" J'ai même tourné sur -Wstrict-aliasing la recherche de problèmes...). Merci pour le +.

OriginalL'auteur Floris
6

Voici une façon de faire ce que vous voulez qui ne cassera pas si vous êtes sur un système par un autre endianness de celui que vous êtes maintenant sur:
```
byte* floatToByteArray(float f) {
    byte* ret = malloc(4 * sizeof(byte));
    unsigned int asInt = *((int*)&f);

    int i;
    for (i = 0; i < 4; i++) {
        ret[i] = (asInt >> 8 * i) & 0xFF;
    }

    return ret;
}
```
Vous pouvez le voir en action ici: http://ideone.com/umY1bB

Le problème avec les réponses ci-dessus, c'est qu'ils s'appuient sur la représentation sous-jacente de floats: C ne garantit pas que l'octet le plus significatif sera la "première" dans la mémoire. La norme permet au système sous-jacent à mettre en œuvre floats cependant, il se sent comme -- donc, si vous tester votre code sur un système avec un type particulier de l'endianness (ordre des octets pour les types numériques dans la mémoire), il cessera de fonctionner selon le type de processeur que vous êtes en cours d'exécution sur.

C'est vraiment un méchant, dur-à-correction d'un bug et vous devriez l'éviter si possible.

Merci pour votre contribution, il ne me préoccupe que d'autres système pourrait mal interpréter une variable de type float. Comment est-ce que votre exemple de code de déterminer entre les systèmes? Pardonnez mon ignorance, j'apprends encore...
Il fonctionne sur les systèmes, car il n'est pas "casser" la notion d'un flotteur que le système fonctionne. À l'aide d'une union interagit directement avec les valeurs en mémoire, donc cela dépend si le système stocke l'octet le plus significatif dans la plus haute octet de poids du flotteur. L'utilisation de cette stratégie passe seulement par d'autres abstractions -- int et bitshifting -- de sorte qu'il sera cohérente, peu importe la façon dont le système sous-jacent, les ordres de ses octets.
Le bit le plus significatif d'un float et un int sera dans le même lieu, indépendamment de l'endianness -- bitshifting de masquage et va sortir correctement. Toutefois, le système ne garantit pas que le bit le plus significatif d'un float est le plus élevé-de l'ordre de bits, de sorte que peut se briser si vous utilisez un union sur un système de différentes boutisme de celui que vous avez développé.
Il n'a pas à faire avec "la mauvaise interprétation d'un flotteur," plutôt, certains systèmes de représenter les nombres en tant que [MOST_SIGNIFICANT_BYTE, 2ND_MOST_SIGNIFICANT, 2ND_LEAST_SIGNIFICANT, LEAST_SIGNIFICANT] et d'autres de les représenter en tant que [LEAST_SIGNIFICANT, 2ND_LEAST_SIGNIFICANT, 2ND_MOST_SIGNIFICANT, MOST_SIGNIFICANT].
Ahh je crois que je vois, il compare le premier nombre de bits significatifs à l'aide de bits de masquage, pour un autre type int ou float à assurez-vous que les octets sont dans le bon ordre. C'est cette sorte de droit?

OriginalL'auteur Patrick Collins

Je voudrais vous recommandons d'essayer une "union".

Regarder ce post:

http://forum.arduino.cc/index.php?topic=158911.0

typedef union I2C_Packet_t{
 sensorData_t sensor;
 byte I2CPacket[sizeof(sensorData_t)];
};

Dans votre cas, quelque chose comme:

union {
  float float_variable;
  char bytes_array[4];
} my_union;

my_union.float_variable = 1.11;

OriginalL'auteur FoggyDay

3

Encore une autre façon, sans les syndicats:
(En supposant que l'octet = unsigned char)
```
void floatToByte(byte* bytes, float f){

  int length = sizeof(float);

  for(int i = 0; i < length; i++){
    bytes[i] = ((byte*)&f)[i];
  }

}
```
Avez-vous une source ou d'un exemple de votre réclamation?
Suis-je une erreur de lecture? Selon le lien: Un objet doit avoir sa valeur stockée et accessible uniquement par une lvalue expression qui est l'un des types suivants qui inclut un type de caractère.
Merci. Il était très curieux, que j'ai trouvé ce petit hack pour être utile dans plusieurs situations, mais n'avait pas eu quelque chose de blow up.
Bien, bon à savoir, de toute façon, depuis que je suis probablement un peu trop généreux avec mes typecasting 🙂
De même, j'ai appris quelque chose aujourd'hui. J'ai supprimé mes commentaires ci-dessus maintenant, depuis qu'ils sont juste du bruit et de ne pas contribuer quoi que ce soit. Un vote...

OriginalL'auteur Christopher Schneider
2

Bien que les autres réponses montrent comment accomplir cela en utilisant un syndicat, vous pouvez l'utiliser pour mettre en œuvre la fonction que vous voulez comme ceci:
```
byte[] float2Bytes(float val)
{
    my_union *u = malloc(sizeof(my_union));
    u->float_variable = val;
    return u->bytes_array;
}
```
ou
```
void float2Bytes(byte* bytes_array, float val)
{
    my_union u;
    u.float_variable = val;
    memcpy(bytes_array, u.bytes_array, 4);
}
```
Vous êtes de retour pointeur vers une variable locale. Une fois le bloc de fonction se termine, u n'existent pas. Vous pouvez allouer dynamiquement de l'union à son pointeur: my_union *u = malloc(sizeof(my_union));.
C'est un peu plus l'habitude d'écrire u->float_variable plutôt que (*u).float_variable, n'est-ce pas? Aucune raison particulière pour laquelle vous avez choisi de cette façon? Notons également que, dans la question, la signature de la fonction adopté le pointeur vers le résultat en tant que paramètre.
De travail du téléphone. Était trop paresseux pour trouver l' > personnage. Fixe maintenant.

OriginalL'auteur mclaassen

cela semble fonctionner aussi

#include <stddef.h>
#include <stdint.h>
#include <string.h>

float fval = 1.11;
size_t siz;
siz = sizeof(float);

uint8_t ures[siz];

memcpy (&ures, &fval, siz);

puis

float utof;
memcpy (&utof, &ures, siz);

aussi pour le double

double dval = 1.11;
siz = sizeof(double);

uint8_t ures[siz];

memcpy (&ures, &dval, siz);

puis

double utod;
memcpy (&utod, &ures, siz);

OriginalL'auteur Enzo Guerra

Vous devez vous connecter pour publier un commentaire.