std :: map of member function punteros?

Question

Necesito implementar un std::map con <std::string, fn_ptr> pares. Los punteros de función son punteros a métodos de la misma clase que posee el mapa. La idea es tener acceso directo a los métodos en lugar de implementar un interruptor o un equivalente.

(estoy usando std::string como claves en el mapa)

estoy bastante nuevo en C++, por lo que cualquier persona podría publicar algunos pseudo-código o enlace que habla de la implementación de un mapa con punteros de función? (sugerencias de métodos pertenecientes a la misma clase que posee el mapa)

Si cree que hay un mejor enfoque para mi problema, las sugerencias también son bienvenidas.

Answer 1

Esto es lo más simple que se me puede ocurrir. Tenga en cuenta que no se verifican errores, y el mapa podría ser útil de manera estática.

#include <map> 
#include <iostream> 
#include <string> 
using namespace std; 

struct A { 
    typedef int (A::*MFP)(int); 
    std::map <string, MFP> fmap; 

    int f(int x) { return x + 1; } 
    int g(int x) { return x + 2; } 


    A() { 
     fmap.insert(std::make_pair("f", &A::f)); 
     fmap.insert(std::make_pair("g", &A::g)); 
    } 

    int Call(const string & s, int x) { 
     MFP fp = fmap[s]; 
     return (this->*fp)(x); 
    } 
}; 

int main() { 
    A a; 
    cout << a.Call("f", 0) << endl; 
    cout << a.Call("g", 0) << endl; 
} 

Answer 2

Una implementación de plantilla podría quedar así:

class Factory { 
public: 
    enum which { 
     foo, bar, baz 
    }; 

    template<which w> 
    A* newA(...); 
    ... 
}; 
template<Factory::which w> 
A* Factory::newA(...) { 
    /* default implementation */ 
    throw invalid_argument(); 
} 
template<> 
A* Factory::newA<Factory::foo>(...) { 
    /* specialization for a 'foo' style A */ 
    ... 
} 
.... 

Esto requiere que el valor utilizado para determinar qué newA se llama ser conocido en tiempo de compilación. Podría utilizar un const char * como parámetro de plantilla, pero no se garantiza que funcione en todos los compiladores.

Otra opción más es crear fábricas auxiliares, una para cada método de creación de fábrica, y almacenarlas en el mapa. Esta no es una gran ventaja sobre el almacenamiento de punteros de método, pero sí le permite definir un método de creación predeterminado y simplifica la obtención de elementos del mapa (no es necesario verificar que la clave exista, porque obtendrá una fábrica predeterminada). En el lado negativo, se agregará una entrada para cada clave desconocida al mapa.

Además, si utiliza un enum en lugar de una cadena para el tipo de clave, no debería tener que preocuparse por comprobar si existe una clave en el mapa. Si bien es posible que alguien pase una clave enum no válida a newA, tendrían que lanzar explícitamente el argumento, lo que significa que no lo van a hacer por accidente. Me está costando imaginar un caso en el que alguien causaría un bloqueo intencionalmente en newA; los escenarios potenciales implican seguridad, pero un programador de aplicaciones podría bloquear la aplicación sin usar su clase.

Answer 3

Otra opción es usar delegados como opuestos a los punteros de función. This la implementación de delegados es bastante rápida, admite polimorfismos y funciona bien con contenedores STL. Usted podría tener algo como:

class MyClass { 
public: 
    // defines 
    typedef fastdelegate::FastDelegate2<int, int, int> MyDelegate; 
    typedef std::map<std::string, MyDelegate> MyMap; 

    // populate your map of delegates 
    MyClass() { 
     _myMap["plus"] = fastdelegate::MakeDelegate(this, &Plus); 
     _myMap["minus"] = fastdelegate::MakeDelegate(this, &Minus); 
    } 

    bool Do(const std::string& operation, int a, int b, int& res){ 
     MyMap::const_iterator it = _myMap.find(operation); 
     if (it != _myMap.end()){ 
      res = it.second(a,b); 
      return true; 
     } 

     return false; 
    } 
private: 
    int Plus (int a, int b) { return a+b; } 
    int Minus(int a, int b) { return a-b; } 
    MyMap _myMap;  
};  

Answer 4

Como C++ 14, podemos usar una lambda genérica para deshacerse fácilmente de punteros a métodos miembros.
Sigue un ejemplo mínimo, trabajando de una función de avance realizado con una función lambda genérica:

#include<utility> 
#include<map> 
#include<string> 
#include<iostream> 

struct SomeClass { }; 
struct SomeOtherClass { }; 

struct Test { 
    void test(SomeClass) { std::cout << "SomeClass" << std::endl; } 
    void test(SomeOtherClass) { std::cout << "SomeOtherClass" << std::endl; } 
}; 

int main() { 
    Test test; 

    auto l = [&test](auto c){ test.test(c); }; 
    std::map<std::string, decltype(l)> m; 

    m.emplace("foo", l); 
    m.emplace("bar", l); 

    m.at("foo")(SomeClass{}); 
    m.at("bar")(SomeOtherClass{}); 
}