Buscando el código más elegante despachador

Question

Creo que el problema es bastante común. Tiene una cadena de entrada y tiene que llamar a una función según el contenido de la cadena. Algo así como un interruptor() para cadenas. Piensa en las opciones de línea de comando.

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

y en la cabecera

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

Así que cada foo y bar tengo que repetir cuatro (4!) Veces. Sé que puedo alimentar los punteros de función y las cadenas a una matriz estática antes y hacer el envío en un bucle, guardando algunas líneas if ... else. ¿Pero hay algún truco de macro (o abuso de preprocesador, según el POV), que hace que sea posible definir de alguna manera la función y al mismo tiempo hacer que actualice la matriz automágicamente? Entonces, ¿tendría que escribir solo dos veces, o posiblemente una vez si se usa en línea?

Estoy buscando una solución en C o C++.

Answer 1

La solución macro feo, que tipo de pedido. Tenga en cuenta que no se registra automáticamente, pero mantiene algunas cosas sincronizadas, y también causará errores de compilación si solo agrega a las asignaciones, y no la función en el archivo fuente.

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

Parece que usted está buscando el Algo Command pattern

así:

crear un mapa como éste

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

continuación, sólo tiene que utilizar su clave para ejecutar el comando como este. ...

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

Para registrar sus comandos simplemente haga este

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

Answer 3

as alternative to the Command pattern se puede construir una tabla hash de cadena - punteros>función:

typedef void (*cmd)(string); 

Answer 4

La solución básica, por mi enlace en el comentario cuestión, es para mapear una cadena a una llamada a función de algún tipo.

Para registrarse en realidad la cadena -> función de puntero/funtor par:

En primer lugar, tienen un producto único objeto despachador (choque de horror!). Llamémoslo TheDispatcher: es un contenedor para map<string,Func>, donde Func es su puntero de función o tipo de functor.

Entonces, tienen una clase de registro:

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

Ahora en sus unidades de compilación individuales se crea objetos estáticos (choque de horror!):

Register r1_("hello", DoSayHello); 

Estos objetos se crearán (suponiendo el código no está en una biblioteca estática) y se registrará automáticamente con TheDispatcher.

Y en tiempo de ejecución, busca cadenas en TheDispatcher y ejecuta la función/functor asociado.

Answer 5

Deberá al menos definir las funciones y agregarlas a algún registro. (Si van a ser funciones miembro no en línea de alguna clase, también deberá declararlas). Aparte de algún lenguaje específico de dominio que genere el código real (como cjhuitt's macro hackery), no veo forma de evitar mencionar estas funciones dos (o tres) veces