Convertion d'entiers/flottant vers un char*

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,

tu as de petites erreurs, voici un correctif (je ne me suis pas préoccupé des cast) :

Merci pour ta réponse,

je vais tester ça cet après-midi!

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)

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.

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

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.

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+

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.

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+