Discussion :

[boubouboy]

Bonjour a tous,

Je poste ici car je n'ai pas trouvé de réponse qui me donne satisfaction sur les différentes pages que j'ai visité.

Je suis en train de faire un programme en C++ dans lequel j'ai un client/serveur TCP. le serveur/client envoi des messages structurés avec des attributs identique pour tous les messages et d'autres spécifique au message.
exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
struct messageN
{
       messageSize
       messsageID
       struct specifiqueAuMessageN
}

Je souhaite avoir une méthode template sendMessage(struct messageN, enum connectionType). C'est à dire qui sera capable de traiter une structure de type message1, message2, .. messageN. Le but de cette methode serait de copier la structure dans un tableau, pour en fonction de l'enum l'envoyer dans une methode send() ou write() de linux (voir windows plus tard).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
//code de la supposée methode
sendMessage(struct messageN, enum connectionType)
{ 
    char data[255];
    memcpy(data, &messageN, messageN.messageSize);
 
    if(connectionType == TCP)
    {
       send(fdSocket, data, messageN.messageSize);
    }
}

Pour faire cela, suis-je obligé de créer:
-sendMessage(struct message1, enum connectionType)
-sendMessage(struct message2, enum connectionType)
- ...
-sendMessage(struct messageN, enum connectionType)

Ou puis je passer par une methode template? Chose que je n'ai jamais utilisé et dont j'aimerai apprendre a me servir.
Si non quelles sont mes options?

Je vous remercie par avance.

Cordialement,
boubouboy

[bacelar]

Pourquoi ne pas utiliser Boost ???

http://www.boost.org/doc/libs/1_38_0.../tutorial.html

[dalfab]

Bonjour,

En template la fonction serait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
template<typename M> void sendMessage( const M& msg , enum connectionType )
{ 
    if ( connectionType == TCP )
    {
       send( fdSocket , &msg , sizeof(msg) );
    }
}

Pour la réception, ça ne serait pas aussi simple

[boubouboy]

Merci pour vos réponses, cela fonctionne.
Je n'utilise pas boost simplement parce que j'aime bien comprendre le fonctionnement des choses.

J'ai une autre question un peu plus complexe.
Étant donné que j'ai plusieurs type de message différents, je les stockes dans des FIFO qui sont ensuite dépilées par un thread qui les envoies vers la methode template send<>() .

Pour les ajouter dans les FIFO j'utilise pour l'instant des methodes addMsg(message1), addMsg(message2), .. addMsg(messageN)

Est-il possible de templatiser ces méthodes, sachant qu'en fonction du type du message je ne le stock pas dans la même fifo??

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
//actuellement, j'ai quelque chose comme ca:
 
addMsg(const message1& msg)
{
   if(connectionType != NONE_COMMUNICATION)
    {    
 
    	if((_Message1QueueQueue.size()<_msgInQueueNbMax) && (_bCancelled == false))
    	{
    		_Message1QueueQueue.push_back(msg);
    	}
    }   
 
}
 
 
addMsg(const message2& msg)
{
   if(connectionType != NONE_COMMUNICATION)
    {    
 
    	if((_Message2QueueQueue.size()<_msgInQueueNbMax) && (_bCancelled == false))
    	{
    		_Message2Queue.push_back(msg);
 
    	}
    }   
 
}

en d'autre terme est ce possible de vérifier le type du paramètre en entrée pour l'envoyer dans le bonne FIFO?

Merci

[JolyLoic]

en d'autre terme est ce possible de vérifier le type du paramètre en entrée pour l'envoyer dans le bonne FIFO?

Pour faire une sorte de if en fonction du type d'un argument template, le plus simple est d'utiliser la surcharge :
Tu définis une fonction sendToFifo que tu surcharges pour chaque type supporté par ton template, et qui envoie au bon endroit, et tu l'appelles depuis ton template.

[boubouboy]

Oui cela fonctionne effectivement, mais c'est actuellement ce que je fais avec les méthodes addMessage qui sont surchargées en fonction du type du message, cela ne fait que déporter le problème dans une méthode "plus profonde de la classe".

Mais je vais m'en tenir à ce principe pour l'instant.

Merci

[jo_link_noir]

Tu peux aussi mettre toutes les fifos dans un tuple et récupéré la bonne fifo avec std::get<Fifo<TypeDeMessage>>(tuple). En supposant que la fifo soit template.

[boubouboy]

Merci pour l'info sur les turples, mais je ne pense pas être assez expérimenté en C++ pour me lancer la-dedans.
Je garde l'idée dans un coin pour les prochaines évolutions de mon projet.
Merci