Discussion :

[uriotcea]

Bonjour,

Je cherche à faire quelque chose qui est peut-etre impossible.
J'ai des variables de type différents tel

Code :

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

1
2
3
4
5
 
double my_var1;
int my_var2;
float my_var3;
...

Je voudrais pouvoir accéder, modifier l'une ou l'autre connaissant le nom de la variable dans une chaine de caractére tel : string nom="my_var1"

Meric de votre aide

[Klaim]

Le language C++ ne permet pas de faire cela nativement.

D'ailleurs, c'est rarement nécessaire pour ce type de language. Il y a des solutions qui pourraient t'interesser, mais avant il faudrait nous dire ce que tu essaies de faire exactement, dans l'ensemble.

[uriotcea]

Merci, je m'en doutais un peu. Je sais comment faire autrement en testant simplement les chaines une à une. C'est simple, plus lourd et bien moins élégant, mais bon ca fonctionne.

[Neckara]

Si tu te fait une classe

Code :

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

1
2
3
4
5
6
7
 
class variable
{
     string nom;
     void *pointeur;
     // int type ?
}

Si tu fait une liste de variables triée sur le nom, tu peux effectuer des recherches dichotomiques, c'est déjà plus rapide.

[Ekleog]

[EDIT : Ce qui suit est horrible, se référer à mon EDIT en bas]

Code :

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

1
2
3
4
5
6
7
8
std::map<std::string, int *> vars;
#define DEF(Var) int Var; vars.insert(std::make_pair(#Var, &Var));
// ...
DEF(my_var1);
DEF(my_var2);
DEF(my_var3);
// ...
(*vars["my_var1"])++; // Incremente my_var1

Plus proprement fait avec boost::any.

Sinon, pour gérer des variables de n'importe quel type, c'est quasiment impossible.

[EDIT]
Bon, j'étais pressé, depuis je suis revenu.
J'ai fait un petit programme avec exemple qui illustre une bien meilleure façon de faire. Bon, ça implique d'ajouter un peu de code, mais ça peut s'avérer utile.
J'ai envoyé sur github : http://github.com/Ekinox/misc/blob/master/namedvars.cpp
Il y a beaucoup de ligned de code, mais un bon nombre sont des commentaires. (oui, désolé, je commente toujours en anglais)
Et le reste sont des lignes à C/C dans ton code source.
Les dernières lignes (185-204) montrent un main() d'exemple, qui montre comment utiliser avec des <int>. Bon, c'est nettement plus complexe à utiliser quand on a plusieurs types, mais c'est "la faute" (grâce, à mon avis) au typage fort du c++.
Un C/C ici :

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
////////////////
// DEFINITION //
////////////////
#include <map>
#include <stack>
#include <stdexcept>
#include <string>
 
/// RegisterEntry
///
/// A class to model a varible pointer to any type.
///
/// It is up to the user to determine to which type it points to.
///
/// It will raise an error when trying to access it if in an invalid
/// state.
/// You may avoid this exception by checking if the entry is valid()
/// before using as<T>().
///
/// Its only publicly-used methods should be valid() and as<T>().
class RegisterEntry {
    private:
        void * ptr_;
    public:
        RegisterEntry();
        bool valid() const;
        template <typename T>
            explicit RegisterEntry(T & val);
        template <typename T>
            T & as();
};
 
/// Register
///
/// The class storing all the Name-Entry pairs.
/// It is implemented as a stack, to allow redefining new variables with
/// the same name. (e.g. recursive functions)
///
/// Its only publicly-used method should be get().
class Register {
    private:
        typedef std::stack<RegisterEntry> Stack_;
        typedef std::map<std::string, Stack_> Map_;
        typedef Map_::iterator It_;
 
        Map_ map_;
    public:
        void push(std::string const & name, RegisterEntry var);
        void pop(std::string const & name);
        RegisterEntry get(std::string const & name);
};
 
/// getGlobalRegister()
///
/// Returns an unique static register.
/// It is the one selected by default when creating a Registered<T>, if
/// none is explicitly specified.
Register & getGlobalRegister();
 
/// Registered<T>
///
/// Models a registered variables.
///
/// Usage :
/// * Use special constructor : Registered<MyType>("VarName", MyValue)
/// It adds the variable name.
/// The MyValue will be selected as the value of the Registered<MyType>.
/// * Use as a normal variable of type MyType
/// * Access from the specified register (or the global register) at any time !
/// * Use name() if ever you didn't remember the variable name
/// I didn't find yet any interesting usage of this, but maybe could it get
/// useful ... So I wrote it !
template <typename T>
class Registered {
    private:
        Register * reg_;
        std::string name_;
        T val_;
    public:
        Registered(std::string const & name, T const & val,
                   Register & reg = getGlobalRegister());
        ~Registered();
        Registered<T> & operator = (T const & val);
        operator T & () ;
        operator T const & () const;
        std::string const & name() const;
};
 
/// InvalidRegisterEntryException
///
/// Exception raised when somebody tries to access a register entry (using
/// as<T>) that is not a valid one.
///
/// It is likely to happen if the variable name asked to the register
/// doesn't exist.
class InvalidRegisterEntryException : public std::runtime_error {
    public:
        InvalidRegisterEntryException();
};
 
////////////////////
// IMPLEMENTATION //
////////////////////
#include <map>
#include <stack>
#include <stdexcept>
#include <string>
 
RegisterEntry::RegisterEntry()
    : ptr_(0)
{ }
bool RegisterEntry::valid() const {
    return ptr_ != 0;
}
template <typename T>
RegisterEntry::RegisterEntry(T & val)
    : ptr_(static_cast<void *>(&val))
{ }
template <typename T>
T & RegisterEntry::as() {
    if (!valid()) throw InvalidRegisterEntryException();
    return *static_cast<Registered<T> *>(ptr_);
}
 
void Register::push(std::string const & name, RegisterEntry var) {
    std::pair<It_, bool> inserted = map_.insert(std::make_pair(name, Stack_()));
    inserted.first->second.push(var);
}
void Register::pop(std::string const & name) {
    It_ it = map_.find(name);
    it->second.pop();
    if (it->second.empty()) {
        map_.erase(it);
    }
}
RegisterEntry Register::get(std::string const & name) {
    It_ it = map_.find(name);
    if (it == map_.end()) {
        return RegisterEntry();
    } else {
        return it->second.top();
    }
}
 
Register & getGlobalRegister() {
    static Register reg;
    return reg;
}
 
template <typename T>
Registered<T>::Registered(std::string const & name, T const & val, Register & reg)
    : reg_(&reg), name_(name), val_(val) {
    reg_->push(name_, RegisterEntry(*this));
}
template <typename T>
Registered<T>::~Registered() {
    reg_->pop(name_);
}
template <typename T>
Registered<T> & Registered<T>::operator = (T const & val) {
    val_ = val;
}
template <typename T>
Registered<T>::operator T & () {
    return val_;
}
template <typename T>
Registered<T>::operator T const & () const {
    return val_;
}
template <typename T>
std::string const & Registered<T>::name() const {
    return name_;
}
 
InvalidRegisterEntryException::InvalidRegisterEntryException()
    : std::runtime_error("Trying to access an invalid register entry.")
{ }
 
///////////////////
// EXAMPLE USAGE //
///////////////////
#include <iostream>
 
int main(int, char**) {
    Registered<int> i1("i1", 0), i2("i2", 2);
    i1 = 1;
    std::string var;
    std::cout << "Recap' : i1 = " << i1 << " ; i2 = " << i2 << std::endl;
 
    std::cout << "Which one to set to 3 ? (i1 / i2) ";
    std::cin >> var;
    getGlobalRegister().get(var).as<int>() = 3;
 
    std::cout << "Which one to increment ? (i1 / i2) ";
    std::cin >> var;
    getGlobalRegister().get(var).as<int>()++;
 
    std::cout << "Which one to display ? (i1 / i2) ";
    std::cin >> var;
    std::cout << var << " = " << getGlobalRegister().get(var).as<int>() << std::endl;
 
    std::cout << "Recap' : i1 = " << i1 << " ; i2 = " << i2 << std::endl;
}

[uriotcea]

Merci "Equinox" pour ton exercice de style, mais force est de constater que cela devient trés complexe au regards d'une solution plus triviale, bien moins élégante je le reconnais, du style:

Code :

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

1
2
3
4
 
  if (mystring=="myvar1")   myvar1=value; 
  if (mystring=="myvar2")   myvar2=value; 
 ...

[screetch]

sinon il y a https://github.com/tegesoft/camp

[Bousk]

Merci "Equinox" pour ton exercice de style, mais force est de constater que cela devient trés complexe au regards d'une solution plus triviale, bien moins élégante je le reconnais, du style:

Code :

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

1
2
3
4
 
  if (mystring=="myvar1")   myvar1=value; 
  if (mystring=="myvar2")   myvar2=value; 
 ...

Tant que tu manipuleras qu'une faible quantité de variables, ça sera suffisant
mais le travail à effectuer à chaque rajout de variable n'en vaut pas forcément le coup

[uriotcea]

Efffectivement, j'en ai une cinquantaine et franchement c'est gérable. J'aurais peu-etre à l'avenir à en rajouter quelques dizaines, mais ca n'ira pas plus loin.
D'une maniére plus général, j'estime que la productivité (puisque c'est un sujet en ce moment...) en matiére de developpement compte aussi, même si à terme ce n'est pas un gage de maintenabilité. Cela dit, ici ,c'est un gage de fiabilité.

[therwald]

Je me suis laissé dire que les comparaisons de chaines étaient plutôt lentes...et ton système implique de faire les comparaisons de manière brutales, je ne connais pas spécifiquement camp, mais je pense qu'on peut supposer de leur part un effort d'optimisation à ce niveau. Évidement ça dépend si la vitesse d'accès par nom est un facteur critique (nombre d'accès nommés vs nombres d'accès normaux, besoin de vitesse dans ton application...).

[uriotcea]

La vitesse de lecture de ces variables est négligeable devant les calculs qui vont suivre dans ce programme.

[ymoreau]

Est-ce que te limite au C++ standard, car si jamais tu travailles avec des librairies il y aura peut être des choses toutes prêtes déjà présentes dans ton projet. Avec Qt par exemple tu n'aurais qu'à faire un QHash<QString, QVariant>.

[uriotcea]

Oui je suis sous Qt. Je vais regarder, ca me parait correspondre exactement à ce dont j'ai besoin.

[Ekleog]

sinon il y a https://github.com/tegesoft/camp

Et après on me dit que je sors l'artillerie lourde ... !

Efffectivement, j'en ai une cinquantaine et franchement c'est gérable. J'aurais peu-etre à l'avenir à en rajouter quelques dizaines, mais ca n'ira pas plus loin.
D'une maniére plus général, j'estime que la productivité (puisque c'est un sujet en ce moment...) en matiére de developpement compte aussi, même si à terme ce n'est pas un gage de maintenabilité. Cela dit, ici ,c'est un gage de fiabilité.

50 comparaisons de chaînes de caractères, c'est lourd.
Et la productivité, c'est un copier-coller dans deux fichiers, et un remplacement de la définition des variables à pouvoir accéder par le nom (int var(0) qui devient Registered<int> var("var", 0)). Donc il suffit d'indiquer le nom de la variable et d'ajouter Registered<>. Tout le reste s'utilise exactement comme avant.

Pour la récupération d'une variable, ça se fait comme ça : getGlobalRegister().get("var").as<int>() et ça renvoie une référence vers la variable "var".

Oui je suis sous Qt. Je vais regarder, ca me parait correspondre exactement à ce dont j'ai besoin.

Sauf que c'st grosso modo ce que j'ai proposé, en version intégrée à Qt. Au passage, les trois différences majeures viennent de la structure de donnée (hashmap vs treemap) avantageant Qt (d'où la unordered_map du c++11). Et le faitque la seconde version est malheureusement limitée à Qt. Enfin, elle ne marche pas dans tous les cas de figure (cf. ci-dessous).

En effet, l'utilisation de la solution Qt implique de remplir la hashmap à la main, ainsi que de la passer à toutes les fonctions appellantes.
Et elle ne permet pas de redéfinir une variable.

Exemple avec ma proposition impossible avec la solution Qt (ou extrêmement complexe) :

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
// Copié-collé du code que j'ai proposé en haut (sauf le main d'exemple)
int foo(int a, int b) {
    Registered<int> bar("bar", a), baz("baz", b);
    std::string var;
    std::cout << "bar = " << bar << " ; baz = " << baz << std::endl;
    std::cout << "Ajouter 42 a quelle variable ? (bar/baz) ";
    std::cin >> var;
    getGlobalRegister().get(var).as<int>() += 42;
    if (bar > 100) {
        return baz;
    }
    int val = foo(bar, baz);
    std::cout << "Valeur du sous-appel : " << val << std::endl;
    return val > bar ? baz : bar;
}
 
int main(int, char**) {
    int val = foo(0, 0);
    std::cout << "Valeur finale : " << val << std::endl;
}

Bon, j'admets, c'est un exemple juste fait pour mettre en faute la solution Qt, et il n'a pas d'utilité en soi.

Mais c'est un contre-exemple quand même.

HTH,
Equinoxe

[Flob90]

Le language C++ ne permet pas de faire cela nativement.

D'ailleurs, c'est rarement nécessaire pour ce type de language. Il y a des solutions qui pourraient t'interesser, mais avant il faudrait nous dire ce que tu essaies de faire exactement, dans l'ensemble.

Tu n'as pas réelement répondu à cette intervention de Klaim qui soulève probablement le problème de fond : pourquoi as-tu besoin de faire ca ?

[uriotcea]

Besoin j'ai besoin de faire ca:
C'est historique. j'ai un gros programme de calcul dans les parametres d'entré trés nombreux sont situées d'un fichier binaire. Ce fichier binaire est lu par le programme et l'ensmble des variable est affiché et modifiable par une GUI Qt.
Mon objectif est de permettre de lancer ce code en mode console en permettant à l'utilisateur de modifier une ou plusieurs variable d'entrée.
Revenir sur le format binaire d'input serait titanesque en terme de concéquence pour l'ensemble des utilisateurs.
Ma solution est de permettre la mise en parametre de commande du code certaines de ces variable du style "Mon_code ma_var1=15 ma_var2=25". L'ojectif n'est pas de mettre toutes les variables possibles, il y en a trop, mais au moins les plus pertinantes.
Actuellement ca fonctionne bien comme je voulais. Mais je vais essayer de voir si avec tout ce que l'on m'a proposé je peux pas faire quelquechose de plus élégant.

[Flob90]

L'objectif est donc de lre l'entrée dans l'objectif de modifier l'état de certaines variables du programme ?

Dans ce cas là, un parser me semble une solution adapté à ton problème, regardes du coté de boost::spririt par exemple.