map de méthodes dans la classe

Version imprimable

20/06/2014, 01h27
foudfou

map de méthodes dans la classe
...ou comment appeler des méthodes par une string, au sein de la clasee.

Bonjour,

Est-il possible d'avoir dans la même classe un map de string vers des méthodes de la classe ?

La motivation: dans une classe Config, j'implémente une méthode read(), qui parse un fichier de config, et qui, pour chaque mot-clef, appelle une fonction parseConsume(key, val). Dans parseConsume(), je peux faire des else if (key == "clef1"), mais il me paraissait plus élégant de faire ParseMap::const_iterator iter = parseHandler.find(key), puis (*this.*(iter->second))(val) (ou approchant) où parseHandler serait initialisé dans le constructeur à base de:

Code:

parseHandle["key1"] = &key1Def;

et serait défini ainsi:
Code:

1 2 3 4 5 6 7 8 9 typedef void (Config::* ParseFunc)(std::string); typedef std::map<std::string, ParseFunc> ParseMap; class Config { // ... private: ParseMap parseHandler; // ...
MAIS

au vu des erreurs du compilo, il semble que ce soit plus compliqué, voire impossible. J'ai cru comprendre qu'il faudrait éventuellement utiliser un delegate. Mais bon si on en arrive là, je préfère rester avec mes else if.

Qu'en pensez-vous ?

http://www.developpez.net/forums/ima...AASUVORK5CYII=
http://www.developpez.net/forums/ima...AASUVORK5CYII=
20/06/2014, 01h52
imperio

Je trouve le fait d'utiliser une map pour faire cela tres elegant. Cependant il faudra que tu ajoutes "a la main" les fonctions a appeler selon la "cle" donnee (dans ton constructeur ce sera parfait). Ce topic en parlait plutot bien je trouvais, tu devrais y jeter un coup d'oeil.

A part ca je ne vois pas d'ou vient l'erreur, pourrais-tu nous montrer les messages du compilo s'il-te-plait ?
20/06/2014, 09h03
white_tentacle

La syntaxe des appels vers des fonctions membres via des pointeurs est obscure et très sujette à erreur.

Je te conseille la lecture de ceci :
http://www.parashift.com/c++-faq-lit...-to-memfn.html

et de bien appliquer les conseils qui y sont donnés pour éviter les erreurs.

Normalement, ce que tu décris devrait marcher.

Utilise std::function et std::mem_fn, ce sera plus facile à manipuler qu'un pointeur vers une fonction membre. Exemple :

Code:

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
#include <iostream>
#include <functional>
#include <map>
 
class Config {
  using parse_mem_fn = std::function<void(Config&, std::string const&)>;
  std::map<std::string, parse_mem_fn> handlers_;
 
 public:
  Config() {
    handlers_["key1"] = std::mem_fn(&Config::consumeKey1);
  }
 
  void consumeKey1(std::string const& value) {
    std::cout << "Yay ! " << value << std::endl;
  }
 
  void parseConsume(std::string const& key, std::string const& value) {
    parse_mem_fn & func = handlers_[key];
    if (func) func(*this,value);
  }
 
  void parse() {
    parseConsume("key1","test");
  }
};
 
int main() {
  Config c;
  c.parse();
  return 0;
}

Tu peux aussi tester avec un unordered_map pour voir si ça te fais de meilleures perfs.

Edit:

Je viens de penser à une syntax sympa qui permet d'initialiser handlers_ de manière plus naturelle.

Code:

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
#include <iostream>
#include <functional>
#include <map>
 
class Config {
  using parse_mem_fn = std::function<void(Config&, std::string const&)>;
  std::map<std::string, parse_mem_fn> handlers_ {{ 
    {"key1", std::mem_fn(&Config::consumeKey1)}
    ,{"key2", std::mem_fn(&Config::consumeKey2)}
  }};
 
 public:
  void consumeKey1(std::string const& value) { std::cout << "Yay ! " << value << std::endl; }
  void consumeKey2(std::string const& value) { std::cout << "Ole ! " << value << std::endl; }
 
  void parseConsume(std::string const& key, std::string const& value) {
    parse_mem_fn & func = handlers_[key];
    if (func) func(*this,value);
  }
 
  void parse() {
    parseConsume("key1","test");
    parseConsume("key2","test");
  }
};
 
int main() {
  Config c;
  c.parse();
  return 0;
}

23/06/2014, 00h00
foudfou

Z'êtes trop forts! En fait, mon problème était que je n'avais pas pensé à soit déclarer les typedef dans la classe, soit forward-déclarer la classe avant les typedef.
Merci à tous pour vos réponses éclairées. Merci à jblecanard pour la version c++11!