La sérialisation/Désérialisation d'une structure à un char* en C

Vous pouvez avoir une classe reprensenting l'objet que vous utilisez dans votre logiciel avec toutes les subtilités et membre func et tout ce dont vous avez besoin. Ensuite, vous avez un "sérialisé' struct c'est plus d'une description de ce que sera la fin de la place sur le réseau.

Pour assurer le compilateur va faire ce que vous lui dites de faire, vous avez besoin de le charger d' 'pack' de la structure. La directive que j'ai utilisé ici est pour gcc, consultez votre compilateur doc si vous n'êtes pas à l'aide de gcc.

Puis le sérialiser et désérialiser de routine, il suffit de convertir entre les deux, en veillant à l'ordre des octets et des détails comme ça.

#include <arpa/inet.h>   /* ntohl htonl */
#include <string.h>      /* memcpy */

class Packet {
    int senderId;
    int sequenceNumber;
    char data[MaxDataSize];
public:
    char* Serialize();
    void Deserialize(char *message);
};

struct SerializedPacket {
    int senderId;
    int sequenceNumber;
    char data[MaxDataSize];
} __attribute__((packed));

void* Packet::Serialize() {
    struct SerializedPacket *s = new SerializedPacket();
    s->senderId = htonl(this->senderId);
    s->sequenceNumber = htonl(this->sequenceNumber);
    memcpy(s->data, this->data, MaxDataSize);
    return s;
}

void Packet::Deserialize(void *message) {
    struct SerializedPacket *s = (struct SerializedPacket*)message;
    this->senderId = ntohl(s->senderId);
    this->sequenceNumber = ntohl(s->sequenceNumber);
    memcpy(this->data, s->data, MaxDataSize);
}

OriginalL'auteur 246tNt

int senderId;
int sequenceNumber;
...    
char *message = new char[MaxMailSize];
message[0] = senderId;
message[1] = sequenceNumber;

Vous êtes en écrasant les valeurs ici. senderId et sequenceNumber sont deux entiers et va prendre plus que sizeof(char) octets sur la plupart des architectures. Essayez quelque chose comme ceci:

char * message = new char[MaxMailSize];
int offset = 0;
memcpy(message + offset, &senderId, sizeof(senderId));
offset += sizeof(senderId);
memcpy(message + offset, &sequenceNumber, sizeof(sequenceNumber));
offset += sizeof(sequenceNumber);
memcpy(message + offset, data, MaxDataSize);

EDIT:
fixe code écrit dans un état de stupeur. Aussi, comme indiqué dans un commentaire, un tel paquet n'est pas portable en raison de endian différences.

OriginalL'auteur Jherico

Comme indiqué dans d'autres posts, senderId et sequenceNumber sont tous deux de type int, qui est susceptible d'être plus grande que char, de sorte que ces valeurs seront tronqués.

Si c'est acceptable, alors le code est OK. Si non, alors vous avez besoin de les diviser en leurs constituants octets. Étant donné que le protocole que vous utilisez spécifier l'ordre des octets de multi-octets des champs, le plus portable et le moins ambiguë, la façon de le faire est par le biais de changements de vitesse.

Par exemple, disons que senderId et sequenceNumber sont à la fois 2 octets de long, et le protocole exige que l'octet de poids fort va d'abord:

char* Serialize() {
    char *message = new char[MaxMailSize];

    message[0] = senderId >> 8;
    message[1] = senderId;

    message[2] = sequenceNumber >> 8;
    message[3] = sequenceNumber;

    memcpy(&message[4], data, MaxDataSize);

    return message;
}

Je recommande aussi le remplacement de la for boucle avec memcpy (si disponible), car il est peu probable d'être moins efficace, et ça rend le code plus court.

Enfin, tout cela suppose que char est un octet de long. Si ce n'est pas le cas, alors toutes les données devront être masquées, par exemple:

    message[0] = (senderId >> 8) & 0xFF;

OriginalL'auteur Steve Melnikoff