transfert entier sur une socket en C

Tout d'abord, sizeof(int) peuvent différer sur votre émetteur et le récepteur de la machine. Donc, je vous recommande d'utiliser quelque chose comme int32_t de stdint.h.

Aussi, il n'est pas garanti que read(..,..,sizeof(int)) va lire exactement sizeof(int) octets - il peut rien lu, ou il peut lire moins octets. Ainsi, la variante correcte sera quelque chose comme ceci:

int send_int(int num, int fd)
{
int32_t conv = htonl(num);
char *data = (char*)&conv;
int left = sizeof(conv);
int rc;
do {
rc = write(fd, data, left);
if (rc < 0) {
if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
//use select() or epoll() to wait for the socket to be writable again
}
else if (errno != EINTR) {
return -1;
}
}
else {
data += rc;
left -= rc;
}
}
while (left > 0);
return 0;
}
int receive_int(int *num, int fd)
{
int32_t ret;
char *data = (char*)&ret;
int left = sizeof(ret);
int rc;
do {
rc = read(fd, data, left);
if (rc <= 0) { /* instead of ret */
if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
//use select() or epoll() to wait for the socket to be readable again
}
else if (errno != EINTR) {
return -1;
}
}
else {
data += rc;
left -= rc;
}
}
while (left > 0);
*num = ntohl(ret);
return 0;
}

Depuis, personne n'a mentionné sprintf

il vous suffit de convertir tout variable à char* l'aide et de l'envoyer

if(strcmp(buf,"movUP") == 0)
{
char* msg = calloc(1, 20);
pos.y += 0.0001f;
sprintf(msg,"NEW::POS::Y=%.4f", pos.y);
sendto(master, msg, 20, 0, (struct sockaddr*)&client, addrlen);
}

Test

movUP
NEW::POS::Y=0.0001
movUP
NEW::POS::Y=0.0002
movUP
NEW::POS::Y=0.0003
movUP
NEW::POS::Y=0.0004

Utilisation %d pour les entiers, %f pour des flotteurs

à reconvertir d'un entier, d'utilisation atoi(char*)

pour reconvertir à un flotteur, utilisez atof(char*)

avant la conversion, assurez-vous d'utiliser strstr() pour obtenir la valeur float seulement, à partir de "0"

    float myPos; //floating variable that stores Object's Position in the World
...
....
memset(buf, 0, MAXBUFFER); //clears the previous buffer
recvfrom(master, buf, MAXBUFFER, 0, (struct sockaddr*)&server, &addrlen);
char* newY = strstr(buf, "0");//NEW::POS::Y=0.0001 --->> 0.000100
myPos = atof(newY); //new object's position by the server
printf("My New Position is %.4f\n", myPos); //Out: My New Position is 0.0011 -> 0.0012 -> 0.0013 -> 0.0014.

Pour les entiers (pas positions), vous pouvez utiliser la même technique et multipliez simplement comme

float f = 0.000002f; //that is supposed to be 2 integer value
int i = (int)(f*1000000); //now, i = 2

les méthodes ci-dessus sont totalement sécurisées

Si vous voulez un plus solide de la conversion, vous pouvez utiliser strncpy ou memcpy et couper la chaîne à partir d'un indice donné avec une certaine longueur en supposant que vous connaissez déjà le tampon entrantes, mais de mon point de vue personnel, je ne vous le recommande vraiment, plus précisément dans sans connexion sockets comme celui-ci, beaucoup de calculs et d'appels à la longueur du tampon, Pas facile à déboguer, parfois, si vous n'êtes pas tout à fait conscient de ce que vous faites.

Note 1: attention, pour pas inclure zéros dans votre tampon lorsque vous êtes en attente d'un serveur déplacer/position de commande ou de toute
quantité variable si vous avez l'intention d'utiliser le 1er méthode.

Note 2: Vous pouvez tout simplement envoyer votre entier ou float, convertir et vice versa sans avoir besoin de couper ou multiplier il.

Peut nouveau jeu en réseau des développeurs de trouver cette réponse utile, car nous ne pouvons pas envoyer ou de recevoir à l'exception char* avec UDP sendto () recvfrom().