Structure vers char* et vice versa
Bonjour à tous et à toutes !
J'aurais une petite question à poser et besoin de vos aides / avis sur un système de transfert de données via réseau...
L'idée est simple ; j'ai une structure qui est seule destinée à traverser le réseau d'un serveur à un client.
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| struct Message
{
struct message1 { int i; };
struct message2 { char c; int i; };
struct message3 { long l; long l2; char c; int i; bool b };
// Vous avez, je pense, compris l'idée :) !
enum MessageType
{
M1, M2, M3
};
MessageType type;
union
{
message1 msg1,
message2 msg2,
message3 msg3
};
}; |
Je souhaiterais envoyé des instances de cette structure le plus facilement possible. J'entends par là limiter les opérations à écrire à l'ajout d'un nouveau type de message. Pour cela, j'ai pensé me servir d'un buffer de char :
Code:
1
2
3
4
5
6
|
Message e; // déjà initialisé
char* buffer = (char*) &e;
std::string sbuffer(buffer, sizeof(e));
// envoie de sbuffer sur le réseau
// j'utilise un std::string intermédiaire pour éviter les surprises liées aux '\0' au milieu du buffer... |
Et pour la réception :
Code:
1
2
3
4
5
6
7
8
|
Message e; // déjà initialisé
std::string sbuffer;
// je remplis ici sbuffer avec ce qui vient du réseau
const char* buffer = sbuffer.c_str();
e = *( (Message*) (buffer)); |
En local, ça marche, aucun problème.
Cela dit, je me pose une question à laquelle je crains imaginer d'avance la réponse... :D
La taille de ma structure "Message" varie t-elle en fonction de l'architecture où l'application est exécutée ? Ce code risque t-il de ne pas fonctionner si la communication se fait entre une machine 32 bits et une machine 64 bits ?
Si ma méthode s'avère problématique, est-il possible de régler le soucis ? Par exemple, serait-il utile de compiler le programme uniquement en 32 bits ? Dois-je utiliser des types spéciaux dans mes structures au lieu des types primitifs de base ?
En vous remerciant d'avance, :)
