Discussion :

[janou195]

Bonjour à tous,

Je souhaiterais me définir une stucture de donné qui contienne un ensemble de paramètres. Chacun de ces paramètres est identifié par un identifiant unique (un string) et est associé à une valeure qui peux être a priori de n'importe quel type.

Pour l'interface de ma structure de donnée, je voudrait pouvoir y ajouter des paramètre de n'importe quel type (ou du moins faisant partie d'un liste de type prédéfinie), qqch dans le style:

Code :

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

1
2
3
4
double foo=1.0;
my_class bar;
ParameterSet.add_parameter("t",foo);
ParameterSet.add_parameter("a",bar);

Ensuite, je souhaiterais pouvoir récuperer les valeurs typées de ces paramètres a partir de leurs identifiants:

Code :

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

1
2
double foo2=ParamSet.get_parameter("t");
my_class bar2=ParamSet.get_parameter("a");

J'ai commencé à regarder du coté du type boost::variant dans l'objectif de faire qqch dans le gout de ce qui suit.

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
42
43
44
45
46
#include <iostream>
#include <stdlib.h>
#include <string>
#include <vector>
 
#include <map>
#include "boost/variant.hpp"
 
using namespace std;
 
typedef boost::variant
<
int,
double,
std::string,
vector<int>
> param_value_type;
 
class ParamSet {
public:
    void add_param(string id, param_value_type val) {
        map_.insert(pair<string, param_value_type>(id, val));
    };
    map<string,param_value_type> map_;
};
 
int main(int argc, char** argv){
 
    int i=2;
    double d=1.2;
    string s="plop";
 
    ParamSet paramset;
    paramset.add_param("i",i);
    paramset.add_param("d",d);
    paramset.add_param("s",s);
 
    int i2=boost::get<int>(paramset.map_["i"]);
    double d2=boost::get<double>(paramset.map_["d"]);
    string s2=boost::get<string>(paramset.map_["s"]);
 
    cout << "i2=" << i2 << endl;
    cout << "d2=" << d2 << endl;
    cout << "s2=" << s2 << endl;
 
}

Ce qui ne me convient pas dans cet exemple: pour récuperer les valeurs typées des paramètres, je voudrais que l'utilisateur n'ai pas à s'embéter avec la syntaxe de boost. Je voudrais que l'utilisation de boost soit gérée en interne dans la classe ParamSet et remplacer en gros:

Code :

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

int i2=boost::get<int>(paramset.map_["i"]);

Par une méthode avec un syntaxe du style:

Code :

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

int i2=paramset.get("i");

Merci d'avance pour votre aide!

[Emmanuel Deloget]

Ce qui ne me convient pas dans cet exemple: pour récuperer les valeurs typées des paramètres, je voudrais que l'utilisateur n'ai pas à s'embéter avec la syntaxe de boost. Je voudrais que l'utilisation de boost soit gérée en interne dans la classe ParamSet et remplacer en gros:

Code :

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

int i2=boost::get<int>(paramset.map_["i"]);

Par une méthode avec un syntaxe du style:

Code :

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

int i2=paramset.get("i");

Merci d'avance pour votre aide!

Impossible : le compilateur a besoin de savoir quelle fonction get() appeler. Pour faire son choix, il dispose des informations suivantes :

1) le type de paramset
2) le type des arguments.

Il ne prends PAS en compte le type de retour de get(), parce que le type de retour de get et le type de l'instance dans laquelle est stockée ce type de retour n'est pas la même et il n'existe pas nécessairement de lien logique entre ces types (par ex, get() peut renvoyer un const char* et i36 peut être un std::string).

Etant donné que toutes les fonctions get() sont membres de paramset et que toutes les fonctions get() prennent en paramètre une chaine ce caractère, le compilateur ne peut pas déterminer celle qui va lui être utile.

Du coup, tu est obligé d'utiliser la notation get<Type>("param").

[janou195]

Merci pour ta réponse, j'ai donc fait autrement.

[oodini]

Essaye de réfléchir à la possibilité d'avoir la valeur de retour comme argument de la fonction. Cela permettrait d'indiquer implicitement le type attendu lors de l'appel de la fonction.

[gbdivers]

Bonjour

Ca ressemble beaucoup à boost.PropertyMap ce que tu souhaites faire, non ?

[3DArchi]

Essaye de réfléchir à la possibilité d'avoir la valeur de retour comme argument de la fonction. Cela permettrait d'indiquer implicitement le type attendu lors de l'appel de la fonction.

Ca revient à ça :

Code :

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

1
2
3
4
5
6
TYPE var;
init_var(var,paramset);
....
 
template<class T>
void init_var(TYPE &, ParamSet const&);

C'est embêtant comme approche. Ca dissocie la définition de la variable de son initialisation effective. Du coup, ça empêche parfois de rendre une variable constante qui devrait l'être : TYPE const var = boost::get<TYPE>(paramset.map_["i"]);