Convertion d'entiers/flottant vers un char*Résolu

Question

Bonjour!

Dans le cadre d'un échange de données serveur/client, j'ai besoin de convertir plusieurs int dans un char* afin d'envoyer la chaine via protocole UDP :


// mes données a envoyer
short a;
long b;
float c;

ma fonction()
{
   char* chaine_a_envoyer;
   memcpy((void*)&chaine_a_envoyer, ()&a, sizeof(short) );

/* ainsi, je convertis bien mon short en char*; mais comment faire pour ajouter mes autres variables dans la chaine? */

memcpy((void*)&chaine_a_envoyer[sizeof(short)], ()&b, sizeof(short) );
/* je pensais pouvoir faire ca, mais ce n'est pas le cas (au risque de me faire taper sur les doigts...)*/
} 

Je veux ensuite les récupérer, côté serveur sachant que je connais déjà la taille de chacune de mes données a récupérer (short, long, float, unsigned...).

D'avance merci,

katerson · Accepted Answer

Je viens de comprendre ce qui se passe:

KO:
memcpy(&l_msg[0], &MsgNav->Msg_Header.Message_ID,sizeof(int)); 

OK:
int toto = MsgNav->Msg_Header.Message_ID;
memcpy(&l_msg[0], &toto,sizeof(int)); 


Aussi, le debugger de netbeans (mon outil de dev) fait apparemment n'importe quoi (ce qui explique la valeur "90") car j'ai récupéré les valeurs corrects dans d'autres variables.

Conclusion:
Je déconseille Netbeans!

A+

fregolo52 · Answer

tu as de petites erreurs, voici un correctif (je ne me suis pas préoccupé des cast) :
ma fonction()
{
char* chaine_a_envoyer;
int position = 0;
memcpy((void*)chaine_a_envoyer, &a, sizeof(short) ); // attetion pas de & !!! chaine_a_envoyer est un pointeur
position += sizeof(short);

memcpy((void*)&chaine_a_envoyer[position], &b, sizeof(long) ); // là oui il faut le &. chaine_a_envoyer[sizeof(short)] est un char
// attention b est un long !!!
position += sizeof(long);

memcpy((void*)&chaine_a_envoyer[position], &c, sizeof(float) ); 
position += sizeof(float);
...
}

katerson · Answer

Merci pour ta réponse,

je vais tester ça cet après-midi!

katerson · Answer

En fait, il n'y a pas de problème lorsque je fais cela:

memcpy((void*)&chaine_a_envoyer[0], &a, sizeof(short) ); 

Ma chaine est bien remplie; par contre, si j'ajoute par exemple:

memcpy((void*)&chaine_a_envoyer[4], &b, sizeof(short) ); 

rien ne se passe! Ma chaine garde sa valeur précédente et pourtant b et bien initialisé (je le vois en debug)

fregolo52 · Answer

il n'y a aucune raison pour que ca ne marche pas!
S'il y a un souci, monre-moi ton code exact et les valeurs de tes variable et aussi ce que tu vois dans le debugger en mémoire.

katerson · Answer

void MESSAGE_MANAGER::Create_Msg_Navigation(char* l_msg)
{
// je remplis ma struct(en dur pour tester) :
MsgNav->Msg_Header.Message_ID = 12345;
MsgNav->Msg_Header.Message_Sender_Enumerated = 34;

memset(l_msg, 0x0, sizeof(l_msg));
memcpy(&l_msg[0], &MsgNav->Msg_Header.Message_ID,sizeof(int));
memcpy(&l_msg[4], &MsgNav->Msg_Header.Message_Sender_Enumerated, sizeof(int));
}

Le premier memcpy me met "90" dans l_msg et apres le second je garde tjs "90".

Merci d'avance

fregolo52 · Answer

déjà ca c'est pas bon :
memset(l_msg, 0x0, sizeof(l_msg)); 
sizeof(l_msg) = la taille du pointeur, donc 4 !!!!

Je ne vois pas ce que le "90" vient faire ici !! 12345 = 0x3039

Je ne comprends rien, heureusement que le "90" reste après le 2e memcpy, vu que tu copies 4 int plus loin.

katerson · Answer

Merci pour le memset!

Moi non plus je ne comprends rien >> surtout pour le "90" du debugger (j'utilise netbeans sous fedora).

En ce qui concerne le "memcpy", n'y a-t-il pas un autre moyen de faire la même chose?
Je pensais au début à un "snprintf" ?!

A+

fregolo52 · Answer

surtout pas un sprintf !!! tu ne peux gérer que des chaînes de caractères. Ce qui n'est pas du tout ton cas.

Je ne connais pas NetBeans, mais pourquoi utiliser un IDE plutôt orienté Java ? J'ai déjà fait du dév C++ et Java avec Eclipse et il y a une différence entre les 2.
Pour débugger, je préfère kDevelop.

Fait gaffe aussi aux tailles sous Linux, surtout si tu es en 64bit.
int : 4 octets
long : 8 octets (linux 64bit)

Pour mieux debugger, essaie d'utiliser WareShark (ou ethereal) tu verras exactement ce qui est envoyé dans ta trame UDP.

katerson · Answer

Merci pour l'info.
En ce qui concerne mes outils, ils me sont imposés...

Je laisse le topic ouvert si quelqu'un a une idée pour trouver une autre solution qu'un memcpy pour convertir des int/floats en char*.

A+

Convertion d'entiers/flottant vers un char*

10 réponses

Votre réponse