Alla ricerca del più elegante dispatcher di codici

Question

Penso che il problema sia piuttosto comune. Hai una stringa di input e devi chiamare una funzione a seconda del contenuto della stringa. Qualcosa come un interruttore() per le stringhe. Pensa alle opzioni della riga di comando.

Attualmente sto usando:

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) { 
... 
} 

e nell'intestazione

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

Così ogni foo e bar devo ripetere quattro (4!) Volte. So che posso alimentare i puntatori e le stringhe di funzione a un array statico prima e fare il dispatching in un ciclo, salvando alcuni se ... altre linee. Ma c'è qualche trucco macro (o abuso del preprocessore, a seconda del POV), che rende possibile definire in qualche modo la funzione e allo stesso tempo aggiornare automaticamente l'array? Quindi dovrei scriverlo solo due volte, o forse una volta se usato in linea?

Sto cercando una soluzione in C o C++.

Answer 1

La soluzione macro brutto, che tipo di-chiesto. Si noti che non si registra automaticamente, ma mantiene alcune cose sincronizzate, e inoltre causerà errori di compilazione se si aggiunge solo ai mapping e non alla funzione nel file sorgente.

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

Sembra che tu stai cercando il Command pattern

Qualcosa di simile a questo:

creare una mappa di come questo

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

poi basta usare la chiave per eseguire il comando in questo modo. ...

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

Per registrare i comandi basta fare questo

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

Answer 3

as alternative to the Command pattern si può costruire una tabella hash di stringa - puntatori> funzione :

typedef void (*cmd)(string); 

Answer 4

La soluzione di base, per il mio link nel commento questione, è mappare una stringa a una chiamata di funzione di qualche tipo.

Per registrare in realtà la stringa -> Funzione coppia puntatore/funtore:

In primo luogo, hanno un Singleton oggetto dispatcher (shock orrore!!). Chiamiamolo TheDispatcher - è un wrapper per un map<string,Func>, dove Func è il puntatore di funzione o il tipo di functor.

Poi, hanno una classe di registro:

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

Ora nelle vostre singole unità di compilazione si crea oggetti statici (scossa di orrore!):

Register r1_("hello", DoSayHello); 

Questi oggetti verranno creati (supponendo il codice non è in una libreria statica) e si registrerà automaticamente con TheDispatcher.

E in fase di esecuzione, cercare le stringhe in TheDispatcher ed eseguire la relativa funzione/funtore.

Answer 5

Dovrai almeno definire le funzioni e aggiungerle ad un registro. (Se devono essere funzioni di membri non inline di qualche classe, dovrai anche dichiararli.) Oltre a qualche lingua specifica del dominio che genera il codice reale (come cjhuitt's macro hackery), non vedo alcun modo per menzionare queste funzioni due (o tre) volte.