Discussion :

[Argol_Medusa]

Bonjour,

j'ai des nombres en long int ( sur 4 octets ) que je souhaite ajouter dans une trame de char.
pour ce faire, j'utilise le procédé suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
char RX_Value[30];
long int valeur=123456;
RX_Value[0] = valeur       & 0xFF;
RX_Value[1] = (valeur>>8)  & 0xFF;
RX_Value[2] = (valeur>>16) & 0xFF;
RX_Value[3] = (valeur>>24) & 0xFF;

jusque là tout va bien

Maintenant j'aimerai fais la meme chose pour un nombre codé en float ( 4 octets ).

j'ai essaye le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
long int *tmp;
float valeur_float;
valeur_float = 123456.2;
tmp=&valeur_float;

afin d'avoir dans tmp les 4 octets qui me permettraient de stocker ensuite dans le tableau de char :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
RX_Value[0] = *tmp  & 0xFF;
RX_Value[1] = (*tmp>>8)  & 0xFF;
RX_Value[2] = (*tmp>>16) & 0xFF;
RX_Value[3] = (*tmp>>24) & 0xFF;

Mais le compilater ( visual studio ) refuse de compiler en mettant le message d'erreur suivant :

c:\projet\ttcpip.cpp(367) : error C2440: '=' : cannot convert from 'float *' to 'long *'

Quelqu'un sait-il comment réussir à copier ce float sur un char de 4 octet ( sans qu'il n'y ait de conversion ) ?

Merci d'avance

[loicounet]

hello,

tente ca:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
    long int *tmp;
    float valeur_float;
    valeur_float = 123456.2;
    tmp= (long int *)&valeur_float;

[loicounet]

en fait ce que tu veux récupérer c'est quoi?
==>
Les nombres de type float sont codés sur 32 bits dont :
* 23 bits pour la mantisse
* 8 bits pour l'exposant
* 1 bit pour le signe

ou bien la valeur?

[Le Farfadet Spatial]

Salut à tous !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
    long int *tmp;
    float valeur_float;
    valeur_float = 123456.2;
    tmp= (long int *)&valeur_float;

Quel horreur ! Une conversion de type C, la chose qu'il vaut mieux éviter en C++... static_cast, const_cast et dynamic_cast et reinterpret_cast sont la pour ça.

Cela dit, pour répondre à Argol_Medusa, j'aurais besoin de savoir si tu veux convertir le flottant en entier long, où si tu veux enregistrer sa représentation binaire dans un entier long, ce qui n'est pas la même chose. Dans le premier cas, il s'agit d'une conversion, dans l'autre non.

À bientôt.

Le Farfadet Spatial

[Argol_Medusa]

Bonjour et merci pour vos réponses,

Oui en fait je ne veux pas convertir un float en long int ( je perdrais l'information sur les décimales), mais prendre les 4 octets du float
( les 23 bits pour la mantisse, 8 bits pour l'exposant, 1 bit pour le signe ) et les mettre dans un tableau de Char : RX_Value[]

Ce RX_Value[] contient des octets d'une trame, que je dois modifier, en remplaçant 4 octets (les premiers dans l'exemple que j'ai pris au-dessus) par un float avant réémission.


Trame RX_Value[30] _,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,
float ( 4 octets )______________/


Je connaissais pas les static_cast, const_cast et dynamic_cast, je vais regarder l'aide sur ces fonctions c'est peut-etre la solution

[Le Farfadet Spatial]

Salut à tous !

Je connaissais pas les static_cast, const_cast et dynamic_cast, je vais regarder l'aide sur ces fonctions c'est peut-etre la solution

Non, ce n'est pas la solution : ces opérateurs sont là pour effectuer des conversions.

C'est quelque chose de très spécifique que tu cherches à faire, vu que tu veux conserver exactement la même représentation binaire, mais en considérant les variables qui stockent les données non plus comme flottantes, mais comme entiers longs. Il y a un sujet sur Developpez.com qui parle de choses qui ressemblent un peu à ce que tu veux faire, je vais essayer de le retrouver.

À bientôt.

Le Farfadet Spatial

[ram-0000]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
float mon_float = (float)12.34;
unsigned long int *ptr = (unsigned long int *)&mon_float;
unsigned long value = *ptr;
TRACE(L"float %f=%ld", mon_float, value);

Resultat :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

float 12.340000=1095069860

Je pense que cela marche mais quelle horreur !!

[Le Farfadet Spatial]

Salut à tous !

Je n'ai pas testé la solution de Ram_0000, peut-être a-t-elle l'effet escompté.

À bientôt.

Le Farfadet Spatial

[Argol_Medusa]

Resultat :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

float 12.340000=1095069860

Je pense que cela marche mais quelle horreur !!

Oui c'est exactement ça, ça marche !! Merci beaucoup !

Du coup j'ai trouvé aussi une autre méthode avec ( mea culpa ) un memcpy :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
	unsigned char RX_Value[30];
    float valeur_float = 12.34;
    long int entier;
    memcpy( &entier, &valeur_float, 4 ); 
 
	RX_Value[0] = entier       & 0xFF;
	RX_Value[1] = (entier>>8)  & 0xFF;
	RX_Value[2] = (entier>>16) & 0xFF;
	RX_Value[3] = (entier>>24) & 0xFF;
	printf("source = %lf et destination = %ld\n",valeur_float,entier);

sortie :

source = 12.340000 et destination = 1095069860

[koala01]

Salut,

De manière générale, il ne faut JAMAIS faire la moindre prédiction sur la manière dont les différents types primitifs sont représentés en mémoire...

En effet, tout ce que la norme indique, c'est:

1. Que tout type est composé d'un nombre entier de char
2. sizeof(char) = 1 = sizeof(unsigned char) = sizeof(signed char)
3. char <= short <= int <= long <= (long long)
4. unsigned char<= unsigned short <= unsigned int <= unsigned long <= (unsigned long long)
5. signed char<= signed short <= signed int <= signed long <= (signed long long)

Et comme on ne peut déjà même pas être sur du nombre de bits utilisé par un char (qui correspond simplement au nombre de bits nécessaires à la représentation de tous les caractères présents dans la table de caractères de référence), on se rend compte qu'il devient pour ainsi dire impossible de faire la moindre prédiction

Dés lors, il est fortement conseillé, une fois de plus, de passer par les flux de conversion pour s'assurer que l'on récupère bien la donnée telle qu'elle devait se présenter

De manière générale, cela prend une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
int monentier = 15698;// il peut venir de n'importe où ;)
std::stringstream ss;
ss<<monentier;
std::string chaine=ss.str();
//on peut récupérer le nombre de caractères composant la chaine grace à
ss.size();
//ou à 
ss.length();

[Argol_Medusa]

Heu ... c'est à dire, si je suis le raisonnement, qu'un char n'est pas forcément codé sur 1 octet, ou plutot qu'un long int n'est pas forcément codé sur 4 octets c'est ça ?

Est-ce que ça dépend uniquement de la machine cible sur laquelle on compile ( PC, microcontroleur ... ) ou est-ce que sur une même machine ( PC par exemple ) on peut avoir des tailles différentes suivant les compilateurs ?

[Le Farfadet Spatial]

Salut à tous !

Est-ce que ça dépend uniquement de la machine cible sur laquelle on compile ( PC, microcontroleur ... ) ou est-ce que sur une même machine ( PC par exemple ) on peut avoir des tailles différentes suivant les compilateurs ?

Comme la norme ne le précise pas, il peut y avoir des différences entre compilateurs.

Dans les faits, les concepteurs de compilateurs implémentent les types en fonction du matériel, donc les différences sont surtout entre machines différentes.

La norme C99 propose des types dont la taille est fixée par la norme. C++ 0x devrait, si je ne m'abuse, les introduire également.

À bientôt.

Le Farfadet Spatial

[Argol_Medusa]

D'accord, merci beaucoup pour toutes ces précisions.

[koala01]

Tu n'a effectivement déjà aucune garantie qu'un "char" soit codé sur 8 bits.

On a vu, si j'ai bonne mémoire, des cas où ils étaient codés sur 6 bits, et on pourrait très bien envisager qu'un compilateur décide qu'il n'y a pas de différence entre char et char_w, et qu'un char soit donc codé sur 16...

De plus, en prenant le "char" comme unité (le plus petit type primitif représentable), on sait que tous les types seront composés de multiples parfaits du nombre de bits d'un char.

Ainsi, il n'est pas question, avec un char composé de 8 bits, d'envisager un type qui soit composé 20 ou 12 bits

Mais le nombre de char qui entre dans chaque type n'est absolument pas fixé (et je n'ai pas l'impression que C++ 0x ait décidé de changer cela )

Ainsi, je sais que chez moi, un short fait 2 char (ce qui correspond bien à char <= short), mais il pourrait très bien en faire 3 chez toi, ton voisin ou ton meilleur ami...

On sait enfin qu'un char, un signed char et un unsigned char seront composés du même nombre de bits, mais on n'a aucune garantie q'un short, un unsigned short et un signed seront composés du même nombre de char.

Et ce qui est vrai ici pour un short est valable pour tous les autres types primitifs.

En outre, on n'a aucune certitude que ce soit l'unsigned int qui serve pour les pointeur et pour les "size type" (size_t), bien que la norme considère qu'il s'agisse d'un candidat idéal pour ce faire.

[Le Farfadet Spatial]

Salut à tous !

Mais le nombre de char qui entre dans chaque type n'est absolument pas fixé (et je n'ai pas l'impression que C++ 0x ait décidé de changer cela )

Moi non plus, je n'ai rien vu qui aille dans le sens de changer cet état de faits.

À bientôt.

Le Farfadet Spatial

[koala01]

Salut à tous !



Moi non plus, je n'ai rien vu qui aille dans le sens de changer cet état de faits.

À bientôt.

Le Farfadet Spatial

Et pourtant, c'est bien toi qui a écrit

<snip>
La norme C99 propose des types dont la taille est fixée par la norme. C++ 0x devrait, si je ne m'abuse, les introduire également.

[Le Farfadet Spatial]

Salut à tous !

Attention, j'ai dit qu'il me semble que C++ 0x va intégrer les types dont la taille est fixée. D'abord, je conçois aisément que je peux faire une erreur.

Cela dit, je n'ai jamais dit que j'avais vu que la taille des char, par exemple, allait être fixée, ni que le nombre de char dans un int sera déterminée : ce n'est pas parce qu'on peut utiliser int16_t ou uint32_t qu'on peut en déduire qu'un long contient 4 char.

À bientôt.

Le Farfadet Spatial