Vous cherchez le répartiteur de code le plus élégant

Question

Je pense que le problème est assez commun. Vous avez une chaîne d'entrée et devez appeler une fonction en fonction du contenu de la chaîne. Quelque chose comme un commutateur() pour les chaînes. Pensez aux options de la ligne de commande.

Actuellement, je suis en utilisant:

using std::string; 

void Myclass::dispatch(string cmd, string args) { 
    if (cmd == "foo") 
     cmd_foo(args); 
    else if (cmd == "bar") 
     cmd_bar(args); 
    else if ... 
     ... 
    else 
     cmd_default(args); 
} 

void Myclass::cmd_foo(string args) { 
... 
} 

void Myclass::cmd_bar(string args) { 
... 
} 

et dans l'en-tête

class Myclass { 
    void cmd_bar(string args); 
    void cmd_foo(string args); 
} 

Ainsi, chaque foo et bar, je dois répéter quatre (4!) Fois. Je sais que je peux alimenter les pointeurs et les chaînes de fonction en un tableau statique avant de faire le dispatching en boucle, en sauvegardant des lignes if ... else. Mais y a-t-il de la supercherie (ou abus de préprocesseur, selon le POV), qui permet de définir la fonction et de la mettre à jour automagiquement? Donc, je devrais l'écrire seulement deux fois, ou peut-être une fois si utilisé en ligne?

Je cherche une solution en C ou C++.

Answer 1

La solution macro laide, que vous-genre de demandé. Notez qu'il ne s'enregistre pas automatiquement, mais il garde certaines choses synchronisées, et provoquera aussi des erreurs de compilation si vous ajoutez seulement aux mappages, et non la fonction dans le fichier source.

Mappings.h:

// Note: no fileguard 
// The first is the text string of the command, 
// the second is the function to be called, 
// the third is the description. 
UGLY_SUCKER("foo", cmd_foo, "Utilize foo."); 
UGLY_SUCKER("bar", cmd_bar, "Turn on bar."); 

parser.h:

class Myclass { 
... 
protected: 
    // The command functions 
    #define UGLY_SUCKER(a, b, c) void b(args) 
    #include Mappings.h 
    #undef UGLY_SUCKER 
}; 

Parser.cpp:

void Myclass::dispatch(string cmd, string args) { 
    if (cmd == "") 
     // handle empty case 
#define UGLY_SUCKER(a, b, c) else if (cmd == a) b(args) 
#include Mappings.h 
#undef UGLY_SUCKER 
    else 
     cmd_default(args); 
} 

void Myclass::printOptions() { 
#define UGLY_SUCKER(a, b, c) std::cout << a << \t << c << std::endl 
#include Mappings.h 
#undef UGLY_SUCKER 
} 

void Myclass::cmd_foo(string args) { 
... 
} 

Answer 2

On dirait que vous êtes à la recherche de la Command pattern

Quelque chose comme ceci:

Créer une carte comme cette

std::map<std::string, Command*> myMap; 

puis il suffit d'utiliser votre clé pour exécuter la commande comme celui-ci. ...

std::map<std::string, Command*>::iterator it = myMap.find(str); 
if(it != myMap.end()) { 
    it->second->execute() 
} 

Pour enregistrer vos commandes, il vous suffit de faire ce

myMap["foo"] = new CommandFoo("someArgument"); 
myMap["bar"] = new CommandBar("anotherArgument"); 

Answer 3

as alternative to the Command pattern vous pouvez construire une Hashtable de chaîne ->pointeurs de fonction:

typedef void (*cmd)(string); 

Answer 4

La solution de base, par mon lien dans le commentaire de question, est pour mapper une chaîne à un appel de fonction quelconque.

Pour vous inscrire en fait la chaîne -> pointeur fonction/paire foncteur:

Tout d'abord, ont un singleton objet répartiteur (choc horreur!). Appelons-le TheDispatcher - c'est un wrapper pour un map<string,Func>, où Func est le pointeur de fonction ou le type de foncteur.

Ensuite, ont une classe de registre:

struct Register { 
    Register(comst string & s, Func f) { 
     TheDispatcher.Add(s, f); 
    } 
}; 

maintenant dans vos unités de compilation individuelles que vous créez objets statiques (choc d'horreur!):

Register r1_("hello", DoSayHello); 

Ces objets seront créés (en supposant le code n'est pas dans une bibliothèque statique) et s'inscrira automatiquement avec TheDispatcher.

Et lors de l'exécution, vous recherchez des chaînes dans TheDispatcher et exécutez la fonction/foncteur associé.

Answer 5

Vous devrez au moins définir les fonctions et les ajouter à un registre. (Si elles doivent être des fonctions membres non-en-ligne d'une classe, vous devrez également les déclarer.) À part un certain langage spécifique au domaine qui génère le code réel (comme cjhuitt's macro hackery), je ne vois aucun moyen de mentionner ces deux fonctions (ou trois) fois.