Discussion :

[Xorgnem]

Bonjour à tous,

tout d'abord voici ce que j'aimerais faire :

je lis un message où je récupère entre autre des paramètres

Code :

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

1
2
3
4
5
6
boucle tant que(pas fin message)
{
lire type du paramètre
     si type==int alors lire le paramètre, le caster en int et le stocker dans param
     si type==bool alors lire le paramètre, le caster en bool et le stocker dans param
}

Donc voilà, si ca boucle, le paramètre param va etre ecrasé par la nouvelle lecture

Donc j'ai pensé à la solution du tableau qui serait de différents types,
alors à chaque boucle j'incrémente une variable, et j'ecris ds param[0] puis param[1] etc...

Si il y a un moyen plus simple, arrêtez moi tout de suite ...

Sinon, comment fait-on ca ?

J'ai réussi à trouver la notion de conteneur, auquel cas il y aurait typeid() qui permettrait de récupérer le type, ce qui m'arrangerait pour un autre truc!

Suis-je sur la bonne voie ?

[Laurent Gomila]

Tu ne peux pas avoir un tableau contenant des éléments de différents types.

Il faudrait que tu nous expliques un peu le contexte, mais si stocker des types différents est vraiment la solution à ton problème, alors tu as boost.variant ou boost.any qui peuvent ty 'aider.

[Xorgnem]

Je ne pense pas que boost.variant m'aide dans mon cas.
Je reexplique (pas évident d'etre clair ) :
Je recupere un parametre d'un type quelconque, et je veux le mettre dans une variable.
Faisant ca dans une boucle, je ne peux pas declarer une seule variable, meme de type multiple, puisque au deuxieme passage de la boucle, j'ecrase le travail du premier passage de la boucle.

Bon je poste le code parce que la je m'enfonce ...

je lis ce message :
string msgBuf("fMessageBoxA@1930@194Your function is working@194Hey Dude@193MB_OK");

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
31
32
string funcName(readName(msgBuf));
	LPCSTR funcNameL;
	funcNameL=funcName.c_str(); // converts String into LPCSTR
	int loop=0;
->	while(msgbuf[ltr]!='\0')
	{
 
 
		string paramType(readType(msgBuf));
		std::istringstream iss( paramType );
		int paramTypeInt;
		iss >> paramTypeInt;
 
		string paramValue;
 
		switch (paramTypeInt)
		{
			case 193 :
				paramValue=readName(msgBuf);
				break;
			defaut :
				break;
		}
 
	}
 
	FCTX<int, char*, char*, unsigned int>::type        Fn_Ptr;
	Fn_Ptr = (FCTX<int, char*, char*, unsigned int>::type )GetProcAddress(ModId, funcNameL);
	Status = Fn_Ptr(0, "Your function is working", "Hey dude", MB_OK);
	printf ("After function call, status = %i (1 means ok)\n", Status);
	cout<<" Address pointer : "<<Fn_Ptr<<" !! "<<endl;
	cout<<funcNameL<<" ( "<<paramType<<','<<paramValue<<" );"<<endl;

c'est donc paramValue que je recupere. J'aimerais reutiliser paramValue dans la ligne
Status = Fn_Ptr(0, "Your function is working", "Hey dude", MB_OK);
pour avoir
Status = Fn_Ptr(paramValue1, paramValue2, paramValue3, paramValue4);
Donc comment faire pour recuperer mes differents parametres, les mettre dans 4 paramValue differents ? J'avais pensé à un espece de tableau acceptant des types differents, mais comment faire alors?

Merci pour votre aide
Je reviens demain si j'ai besoin d'apporter des precisions

[Laurent Gomila]

Mais là les types sont parfaitement connus, ainsi que le nombre d'éléments. Donc il te suffit de déclarer les 4 variables qu'il te faut.

Tu ne pourras plus utiliser une boucle, mais il suffit de placer ton code de lecture dans une fonction (template) et de l'appeler pour chacune de tes variables.

Sinon, si tu tiens vraiment à avoir un tableau, tu peux utiliser boost.any.

[coyotte507]

j'avais préparé un exemple avec des conteneur... mais là il te suffit simplement de découper ta string avec strtok ou en c++ (avec string.find()) et de stocker les différents paramètres dans des strings ou des chaines de caractères.

Exemple:

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
 
 
string message= "fMessageBoxA@1930@194Your function is working@194Hey Dude@193MB_OK";
 
char *explore = (char*)(void*)message.c_str();
int num;
 
/* on cherche le nombre de @ */
for(num = 1; *explore != 0; ++explore)
{
  if (*explore == '@') ++num;
}
 
/* création du tableau */
string params[num];
 
/* on refait une boucle , cette fois pour placer les éléments*/
int i, j, k;
for (i = 0, j = message.find('@', i), k=0; k < num; ++k, i=j+1, j=message.find('@'))
{
  param[k] = message.substr(j-i);
}
 
/*
  maintenant on a le tableau param
  en fait ca aurait été beaucoup plus simple
  avec strtok
  */

[Luc Hermitte]

Et si tu as 150 options, boost.program_options est un choix possible.
Lectures connexes (pour des solutions plus génériques):
http://www.developpez.net/forums/sho...=1#post1588859
http://www.developpez.net/forums/sho...d.php?t=186236

[loufoque]

Je ne pense pas que boost.variant m'aide dans mon cas.

Pourtant, si.
C'est exactement ce que tu veux d'après la demande de ton premier message.

Sauf que boost.variant ne l'implémente pas comme ça (tu trouveras ce genre de d'interface avec boost.any) mais d'une meilleure manière, plus propre, plus performante (car la recherche du type doit être en O(log n) a priori et non pas en O(n)) et en plus, permet de faire un genre de duck typing avec les templates.

[Xorgnem]

j'avais préparé un exemple avec des conteneur... mais là il te suffit simplement de découper ta string avec strtok ou en c++ (avec string.find()) et de stocker les différents paramètres dans des strings ou des chaines de caractères.

Exemple:

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
 
 
string message= "fMessageBoxA@1930@194Your function is working@194Hey Dude@193MB_OK";
 
char *explore = (char*)(void*)message.c_str();
int num;
 
/* on cherche le nombre de @ */
for(num = 1; *explore != 0; ++explore)
{
  if (*explore == '@') ++num;
}
 
/* création du tableau */
string params[num];
 
/* on refait une boucle , cette fois pour placer les éléments*/
int i, j, k;
for (i = 0, j = message.find('@', i), k=0; k < num; ++k, i=j+1, j=message.find('@'))
{
  param[k] = message.substr(j-i);
}
 
/*
  maintenant on a le tableau param
  en fait ca aurait été beaucoup plus simple
  avec strtok
  */

Salut,
c'est exactement ce que fait ma fonction readName ou readType, elle lit ma chaine msgbuf et stocke dans des strings. Mais ma boucle me sert aussi a transformer mes strings en le type defini dans msgbuf (ce sont les codes 193 ou 194 ca correspond a des types, mon maitre de stage veut que ce soit des numeros, alors on met des numeros)
Et mon msgbuf n'est pas fixe, normalement c'est un message que je recois par ethernet, et il est different a chaque fois, c'est juste un exemple ici pour bosser...

[Laurent Gomila]

Vu que de toute façon tu connais les types (tu passes tes valeurs à une fonction dont le prototype est bien défini), pourquoi ne pas garder tes valeurs sous forme de chaîne et les convertir uniquement au moment de l'appel (là où tu connais le type), par exemple avec boost.lexical_cast ?