Discussion :

[aiolia_aiolos]

Bonjour,

Je voudrais stocker une liste d'arguments dans une std::list mais le problème c'est que je ne sais pas comment m'y prendre pour faire en sorte de pouvoir mettre des arguments de types différents, tout en étant capable ensuite, au moment où j'utiliserais la liste, de connaitre le type des différents éléments stockés.

J'ai pensé aux templates mais le problème c'est que je ne peux avoir qu'une liste de données du même type. J'ai également pensé à un truc dans ce style :

class A {}
template<typename T> class B : public A { T m_Data; }

et ensuite créer une liste de A* :
std::list<A*> listA;

... ce qui pourrait convenir pour stocker les données dans ce style :
B<int> * pb = new B<int>;
listA.push_back(pb);

.. mais le problème c'est qu'ensuite je ne pourrais plus récupérer les données correctement, à moins de connaitre explicitement leur type (ce qui n'est pas le cas évidemment, puisque ça change à chaque exécution).

Si quelqu'un a une solution (qui m'éviterais de devoir stocker explicitement le type de chaque donnée et ensuite de faire des tests du genre if (nType == 1) alors c'est un int, 2 c'est un float, 3 c'est une string etc...), je suis preneur.

Merci d'avance

[Ksempac]

2nde solution (une classe mere dont herite toutes tes classes et une liste d'objets de type ta classe mere) + Dynamic_cast a la sortie

Si le dynamic_cast renvoie autre chose que 0, tu viens de trouver le type de ce qui est sorti.
Si le dynamic_cast renvoie 0, c'est pas le bon type, tu peux tenter le type d'apres.

Cf la FAQ pour plus d'informations sur la syntaxe et l'utilisation de dynamic_cast

[Jean-Marc.Bourguet]

.. mais le problème c'est qu'ensuite je ne pourrais plus récupérer les données correctement, à moins de connaitre explicitement leur type (ce qui n'est pas le cas évidemment, puisque ça change à chaque exécution).

Qu'est-ce que tu veux faire avec des valeurs si tu n'en connais pas le type? Une fois qu'on sait ca, on peut commencer a proposer des solutions.

[aiolia_aiolos]

Qu'est-ce que tu veux faire avec des valeurs si tu n'en connais pas le type? Une fois qu'on sait ca, on peut commencer a proposer des solutions.

Je bosse sur une surcouche de LUA et je dois créer une fonction qui prend en argument la liste de paramètres et effectue, pour chaque valeur de la liste, des traitements spécifiques de lua (lua_pushstring, lua_pushnumber etc...) en fonction du type de la valeur.

[aiolia_aiolos]

2nde solution (une classe mere dont herite toutes tes classes et une liste d'objets de type ta classe mere) + Dynamic_cast a la sortie

Si le dynamic_cast renvoie autre chose que 0, tu viens de trouver le type de ce qui est sorti.
Si le dynamic_cast renvoie 0, c'est pas le bon type, tu peux tenter le type d'apres.

Cf la FAQ pour plus d'informations sur la syntaxe et l'utilisation de dynamic_cast

Oui, mais si j'ai bien compris l'idée, je serais quand même obligé de faire des tests pour chaque valeur du genre : si dynamic_cast<int> (valeur) == NULL alors ce n'est pas un int etc... Or, je voudrais éviter de faire ces tests. J'ai pensé qu'il y'avait sûrement moyen de faire ça d'un façon plus concise et plus optimisée en utilisant les templates mais je ne vois pas comment.

[Jean-Marc.Bourguet]

Je ne vois pas en quoi une solution du genre:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class A {
public:
   virtual void act() = 0;
};
 
class AInt {
   ...
   void act() {lua_pushint(data); }
};
 
class AString {
   ...
   void act() {lua_pushstring(data); }
};

ne convient pas.

[aiolia_aiolos]

Je ne vois pas en quoi une solution du genre:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class A {
public:
   virtual void act() = 0;
};
 
class AInt {
   ...
   void act() {lua_pushint(data); }
};
 
class AString {
   ...
   void act() {lua_pushstring(data); }
};

ne convient pas.

Le problème c'est que ça m'oblige à instancier des classes différentes, or je dois stocker toutes les instances dans une seule liste, donc elle doivent être obligatoirement de même type (enfin si j'ai bien compris, en plus la classe A n'est pas parent des autres)

[Jean-Marc.Bourguet]

Le problème c'est que ça m'oblige à instancier des classes différentes, or je dois stocker toutes les instances dans une seule liste, donc elle doivent être obligatoirement de même type (enfin si j'ai bien compris, en plus la classe A n'est pas parent des autres)

A devait etre parent des autres, c'est un oubli que je vais corriger (sinon, a quoi servirait-elle?)

Tu continues a stocker des pointeurs vers A.

[aiolia_aiolos]

Nom de dieu je suis bête, je crois avoir compris mais il faudrait que je teste

[aiolia_aiolos]

A devait etre parent des autres, c'est un oubli que je vais corriger (sinon, a quoi servirait-elle?)

Tu continues a stocker des pointeurs vers A.

Bon en fait non ça ne peut pas marcher car avec ta technique (polymorphisme classique) , les prototype de Act sont tous les mêmes. Or là, Act doit prendre un argument dont le type dépend justement de la classe en question. Par exemple le prototype du Act de AInt devra être Act ( int ).

Je suis en train d'essayer avec les templates, voilà comment j'ai démarré :

class Var{...};
template<typename T> class TypedVar : public Var {void Push(T value); ...};

class TypedVarInt : public TypedVar<int>
{
Push(int nValue)
{
lua_pushnumber(nValue);
}
}

class TypedVarString : public TypedVar<string>
{
Push(string sValue)
{
lua_pushstring(sValue);
}
}


... et de même pour les autres classes. J'espère que ça va marcher, je vous tiens au courant

[Jean-Marc.Bourguet]

D'ou vient l'argument qui depend du type?

[Médinoc]

Je ne vois pas pourquoi cela devrait influer sur le prorotype de Act().
Selon moi, c'est le constructeur qui devrait dépendre du type...

[aiolia_aiolos]

D'ou vient l'argument qui depend du type?

En gros, voilà à quoi ça devrait ressembler :

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
33
34
35
36
37
38
39
40
41
 
 
class Var {...}
 
 
template<typename T>
class TypedVar : public Var
{
    T value;
public:
    T GetValue() {return value;}
}
 
// Fonction qui appelle une fonction LUA
void CallLUAFunction (const char* szFunctionName,const list& ArgList, list&RetList);
{
    // On récupère tousles arguments
    list<Var*>::iterator itArgList = ArgList.begin();
    while ( itArgList != ArgList.end() )
    {
        Var* pVar = *itArgList;
        // ensuite, on fonction du type de Var, je voudrais appeler une fonction lua :
        // si pVar encapsule un int, cad si pVar référence un TypedVar<int>, alors il faudrait que je puisse faire (mais je sais pas comment) :
        lua_pushint( pVar->GetValue() );
        // si pVar encapsule un string, cad si pVar référence un TypedVar<string>, je voudrais pouvoir faire : 
        lua_pushstring( pVar->GetValue() );
 
        etc...
 
 
    }
}
 
 
// programme client 
list<Var*> ArgList;
Var* p = new TypedVar <int>; 
Arglist.push_back(p);
p = new TypedVar <string>; 
Arglist.push_back(p);
CallLUAFunction ( "MaFonctionLUA", ArgList, RetList);

[Jean-Marc.Bourguet]

Plutot que de faire un push(var->getValue) tu fais var->push().

[aiolia_aiolos]

Plutot que de faire un push(var->getValue) tu fais var->push().

Ah oui en effet, j'y avais pensé à un moment mais ensuite je me suis embrouillé. Je vais tester et je vais te dire si ça marche. Merci !

[Laurent Gomila]

Ton design à base de templates et de polymorphisme paraît assez lourd pour ce que tu veux faire.
Pourquoi ne pas faire de CallLUAFunction une classe, définir les opérateurs adéquats, et utiliser la surcharge pour gérer les différents types ?

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
class LuaFunction
{
public :
 
    LUAFunction(const std::string& FuncName);
 
    // Pour passer des paramètres
    LuaFunction& operator <<(int Arg);
    LuaFunction& operator <<(float Arg);
    LuaFunction& operator <<(const std::string& Arg);
 
    // Pour appeler la fonction
    bool operator ()();
 
    // Pour récupérer les valeurs de retour
    LuaFunction& operator >>(int& Ret);
    LuaFunction& operator >>(float& Ret);
    LuaFunction& operator >>(std::string& Ret);
};
 
LUAFunction F("DoSomething");
F << 5 << "bop";
if (F())
{
    int Ret;
    F >> Ret;
}

Ca s'éloigne un peu de ton design, mais si jamais ça peut donner des idées...
Tu peux aussi remplacer << et >> par (), si tu veux des trucs moins verbeux.

Au fait, c'est pour le fun ? Parce que des wrappers Lua C++, il en existe de très bons (luaBind est sans doute le meilleur).

[aiolia_aiolos]

Ok, ça maaaaarche !!!

Bon merci pour tout et à plus !

[aiolia_aiolos]

Ton design à base de templates et de polymorphisme paraît assez lourd pour ce que tu veux faire.
Pourquoi ne pas faire de CallLUAFunction une classe, définir les opérateurs adéquats, et utiliser la surcharge pour gérer les différents types ?

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
class LuaFunction
{
public :
 
    LUAFunction(const std::string& FuncName);
 
    // Pour passer des paramètres
    LuaFunction& operator <<(int Arg);
    LuaFunction& operator <<(float Arg);
    LuaFunction& operator <<(const std::string& Arg);
 
    // Pour appeler la fonction
    bool operator ()();
 
    // Pour récupérer les valeurs de retour
    LuaFunction& operator >>(int& Ret);
    LuaFunction& operator >>(float& Ret);
    LuaFunction& operator >>(std::string& Ret);
};
 
LUAFunction F("DoSomething");
F << 5 << "bop";
if (F())
{
    int Ret;
    F >> Ret;
}

Ca s'éloigne un peu de ton design, mais si jamais ça peut donner des idées...
Tu peux aussi remplacer << et >> par (), si tu veux des trucs moins verbeux.

Au fait, c'est pour le fun ? Parce que des wrappers Lua C++, il en existe de très bons (luaBind est sans doute le meilleur).

Oups désolé je n'avais pas vu ton message. Ben en fait ce n'est pas pour le fun c'est pour le boulot, mais à vrai dire je fais ce que le chef de projet m'a demandé (en gros reprendre le wrapper de leur moteur et le refaire plus proprement, parce qu'avant ils y allait à coup de test du genre if type=truc then machin )

Sinon pour ton idée de classe, je vais essayer voir ce que ça donne, j'avoue que étant au taf je n'ai pas trop eu le temps de me pencher dessus parce que j'ai pris un peu de retard mais ce soir quand y'aura moins de pression je regarderais (je sais pour avoir lu tes tutoriaux que tu es LE spécialiste des templates et par conséquent je m'attendais à te voir intervenir )

En tout cas merci à vous 2 !

[aiolia_aiolos]

Sinon Loulou à propos de ce que tu propose, je crois que ça ne va pas plaire au lead parce qu'il ne veut pas qu'on réimplémente un nouveau prototype pour chaque type, il veut à tout prix que j'utilise les template (c'est son obsession)

[Laurent Gomila]

je sais pour avoir lu tes tutoriaux que tu es LE spécialiste des templates et par conséquent je m'attendais à te voir intervenir

Il y a ici plein de gens plus compétents que moi pour les templates et le C++ en général (dont Jean-Marc) mais merci pour le compliment

Sinon Loulou à propos de ce que tu propose, je crois que ça ne va pas plaire au lead parce qu'il ne veut pas qu'on réimplémente un nouveau prototype pour chaque type, il veut à tout prix que j'utilise les template (c'est son obsession)

Ok c'était juste une idée.