C ++ Comment envoyer des structures sur socket?

Dire que j'ai une structure:

struct person
{
    char name[10];
    int age;
};

struct car
{
    int locationX;
    int locationY;
};

struct company
{
    vector<person> employees;
    vector<car> cars;
};

Par exemple, je veux send/recv l'ensemble de la company à l'aide de socket (UDP). Donc, envoyer et recv une fois.

Comment puis-je le faire? Pourriez-vous me donner un peu de code sinppet? Comment envoyer tout et tout lire.

Merci!

source d'informationauteur JJ Liu

c++serialization sockets struct

8

Prendre un coup d'oeil à Google protocol buffers http://code.google.com/apis/protocolbuffers/
comme une lite alternative à Stimuler la sérialisation.
17

La formulation de votre question suggère que ce que vous cherchez est: est-ce
```
company foo;
send(sockfd, &foo, sizeof(foo), 0); //DO NOT do this
```
Ce sera essentiellement de vidage de la mémoire de la company struct dans votre prise. Cette ne fonctionnera PAS dans cette instance. Et même quand ça marche, c'est vraiment une mauvaise idée. La raison pour laquelle cela ne fonctionne pas, c'est que vectors ne contiennent pas les données directement. Qu'ils pointent. Cela signifie que lorsque vous videz la structure contenant les vecteurs dans le support, il vous sera dumping des pointeurs à la mémoire, mais pas les trucs qu'il pointe. Il en résultera (au mieux) se bloque sur le côté de réception.

Il serait sorte de travail pour chaque person ou car objets. Ceux-ci contiennent pas de pointeurs, et ainsi de leur la mémoire contient toutes les valeurs pertinentes'

Sur le côté émetteur:
```
person joe = { "Joe", 35 };
send(sockfd, &joe, sizeof(joe), 0); //may work, but is a bad idea, see below
```
Sur le côté de réception:
```
person joe;
recv(sockfd, &joe, sizeof(joe), 0);
```
Mais, c'est toujours une mauvaise idée. Il s'appuie sur le côté émetteur et côté réception ayant exactement la même disposition de la mémoire de leurs structures. Cela peut ne pas être vrai pour un certain nombre de raisons. Certaines sont dotées d'un être sur un PowerPC puce, et l'autre sur un x86 d'Intel de puce. Ou étant sur une machine Windows compilé avec Visual Studio et l'autre sur une machine Linux compilé avec gcc. Ou peut-être quelqu'un a modifié certaines options du compilateur qui cause la structure par défaut de mise en page différente. Un certain nombre de raisons.

Vraiment, vous devez utiliser une infrastructure de sérialisation comme tout le monde ici a suggéré. Je dirais Google protocol buffers ou la Stimuler la sérialisation cadre que d'autres personnes ont déjà lié. Mais il y a beaucoup d'autres.

Une autre infrastructure de sérialisation qui mérite d'être mentionné car il est hyper rapide (presque aussi rapide que tout droit de dumping de la mémoire image d'un struct dans un socket) est Cap'n Proto.
7

Si vous êtes à même de faire grand nombre de ces, vous pouvez regarder dans l'Épargne. Il va automatiquement générer tout le code nécessaire pour sérialiser toutes les structures pour vous afin que vous n'avez pas à le faire manuellement.

Ils soutiennent également des chaînes de caractères donc très pratique.

Oh! Et c'est gratuit. 😎

http://thrift.apache.org/

Une autre chose, il envoie des données binaires en tant que tel, de sorte que vous n'aurez pas à convertir les nombres en chaînes de caractères et vice versa. C'est beaucoup plus rapide de le faire si la plupart de vos données ne sont pas des chaînes.
6

Utilisez le Boost de sérialisation de la bibliothèque:

http://www.boost.org/doc/libs/1_48_0/libs/serialization/doc/index.html

C'est probablement le plus robuste, universel, fiable, facile à utiliser et même de la croix-plate-forme voie à une telle tâche.
5

Comme d'autres l'ont déjà dit, l'utilisation d'un certain type de sérialisation bibliothèque, la plus robuste (et probablement la plus simple à gérer) solution. Si, toutefois, vous êtes vraiment désireux de mettre en œuvre vous-même, puis le suivant montre l ' "idée" de la façon dont peut-être de s'en approcher. La suite alloue un tampon, puis le remplit avec les employés de vecteur de contenu. La variable c est supposé être de type company.

Des choses à noter:
- L'exemple utilise une mémoire tampon de charge jusqu'à entrées multiples pour un seul envoi. Avec UDP, il serait généralement pas souhaitable d'envoyer une entrée à la fois car il en résulterait un paquet par entrée.
- La première valeur stockée dans la mémoire tampon est le nombre d'éléments. Dans la réalité, certaines des informations supplémentaires seraient probablement nécessaires (p. ex., type de données). Sinon, le récepteur ne serait pas nécessairement au courant de ce qu'il faisait.
- Le char de données est copiée et null. Une autre façon serait de préfixe de données avec de la longueur et de renoncer à la terminateur null.
- Il peut être judicieux de stocker les valeurs de nombre entier dans la mémoire tampon aligné sur 4 octets limites (dépend du système).
- htonl est utilisé pour stocker les valeurs entières dans l'ordre des octets de réseau. L'extrémité de réception doit utiliser ntohl de les lire.
Simple et très incomplète exemple:
```
   //allocate buffer to store all the data for a send.  In a real world
   //this would need to be broken up into appropriately sized chunks
   //to avoid difficulties with UDP packet fragmentation.

   //This likely over-allocates because the structure likely has padding
   char *buf = new char[ sizeof( uint32_t ) +   //for total number of entries
                  sizeof( person ) * c.employees.size() ];  //for each entry

   char *pos = buf;
   //Indicate how many are being sent
   *(uint32_t*)pos = htonl( c.employees.size() );
   pos += sizeof uint32_t;
   for ( vector<person>::iterator pi = c.employees.begin();
         pi != c.employees.end(); pi++ )
      {
      *(uint32_t*)pos = htonl( pi->age );
      pos += sizeof uint32_t;
      strcpy( pos, pi->name );
      pos += strlen( pi->name ) + 1;
      }

   send( 0, buf, (int)( pos - buf ), 0 );


   delete [] buf;

   //The receiving end would then read the number of items and 
   //reconstruct the structure.
```

Vous devez vous connecter pour publier un commentaire.