std :: map des pointeurs de la fonction membre?

J'ai besoin de mettre en œuvre un std::map avec <std::string, fn_ptr> paires. Les pointeurs de fonction sont des pointeurs vers des méthodes de la même classe qui est propriétaire de la carte. L'idée est d'avoir un accès direct aux méthodes au lieu de la mise en œuvre d'un commutateur ou d'un équivalent.

( Je suis en utilisant std::string que les clés de la carte )

Je suis assez novice en C++, donc quelqu'un pourrait-il poster quelques pseudo-code ou un lien qui parle de la mise en œuvre d'une carte avec des pointeurs de fonction? ( pointeurs vers des méthodes appartenant à la même classe qui possède la carte )

Si vous pensez qu'il y a une meilleure approche de mon problème, des suggestions sont également les bienvenues.

source d'informationauteur Goles

  1. 25

    C'est le plus simple je peut venir avec. Remarque pas de contrôle d'erreur, et la carte pourrait sans doute être utilement faite statique.

    #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;
}
  2. 3

    Un modèle de mise en œuvre pourrait ressembler à:

    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 */
    ...
}
....

    Cela exige que la valeur utilisée pour déterminer qui newA est appelé à être connu au moment de la compilation. Vous pouvez éventuellement utiliser un const char * que le paramètre du modèle, mais il n'est pas garanti pour fonctionner sur tous les compilateurs.

    Encore une autre option est de créer helper usines, un pour chaque usine, la méthode de création, et de la stocker dans la carte. Ce n'est pas un énorme avantage sur le stockage de la méthode des pointeurs, mais ne vous permettent de définir une valeur par défaut la méthode de création et simplifie l'extraction de choses à partir de la carte (il n'y a pas besoin de vérifier que la clé existe, parce que vous obtiendrez une usine par défaut). Sur le revers de la médaille, une entrée pour chaque clé inconnue serait ajouté à la carte.

    Aussi, si vous utilisez un enum plutôt qu'une chaîne de caractères pour le type de clé, vous ne devriez pas avoir à vous soucier de vérifier si une clé existe dans la carte. Alors qu'il est possible pour quelqu'un de passer un invalide enum clé newAils auraient à convertir explicitement l'argument, ce qui signifie qu'ils ne vont pas le faire par accident. Je vais avoir du mal à imaginer un cas où quelqu'un aurait délibérément provoquer un plantage dans newA; le potentiel de scénarios impliquent de sécurité, mais le programmeur de l'application peut se bloquer l'application sans l'aide de votre classe.

  3. 1

    Une autre option est d'utiliser les délégués que de s'opposer à des pointeurs de fonction. Cette délégué de la mise en œuvre est assez rapide, prend en charge les polymorphismes et joue bien avec les conteneurs stl.
    Vous pourriez avoir quelque chose comme:

    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;    
};
  4. 1

    Depuis C++14, on peut utiliser un générique lambda de se débarrasser facilement des pointeurs de méthodes membres.

    Il en résulte un minimum, exemple de travail d'une fonction composée avec un générique d'une fonction lambda:

    #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{});
}