Table de pointeur de fonction statique/carte en C ++

J'ai une classe de base représentant un gestionnaire pour un hardwre (générique), dont dérivent des instances spécifiques. Le protocole de commande que le gestionnaire reçoit inclut une chaîne qui détermine la fonction que le gestionnaire exécute.

Je voudrais construire un mappage statique de chaînes pour pointer des fonctions en utilisant HashMap (qui est fondamentalement similaire à std :: map pour autant que je sache, donc cela devrait s'appliquer plus -ou-moins à JUCE et std ). Je veux que ce soit statique parce que ce mapping ne changera pas, et je ne veux pas avoir à le reconstruire chaque fois que j'instancie un gestionnaire (ce qui peut arriver beaucoup).

//general hardware handler
class HandlerBase {
public:

   //all command handlers take a BazCommand reference and return success
    typedef bool (HandlerBase::* commandHandler)(BazCommand&);

   //this is the mapping of String to the handler function that
   //determines which function to run when getting a command
    typedef HashMap CmdList;
}

// handler for the Foomatic Barrifier 2000
class FoomaticHandler : public HandlerBase {
public:

    //one of the Foomatic handler functions
    bool barrify(BazCommand& cmd) {
        return true;
    }

    static CmdList createCmdMapping() {
        CmdList l;

        l.set("bar", (commandHandler) &FoomaticHandler::barrify);
       //add all Foomatic handler functions here

        return l;
    }

    bool doCommand(BazCommand& cmd) {
        String cmdString = cmd.getCmdString();

        //execute correct function here
    }

    //this cmdList is static and shared betweeen all Foomatic handlers
    static CmdList cmdList;
}

// set up the Foomatic command hashmap
FoomaticHandler::CmdList FoomaticHandler::cmdList =
        FoomaticHandler::createCmdMapping();

Cependant, cette approche génère beaucoup d'erreurs. J'ai essayé plusieurs arrangements alternatifs. Celui-ci produit:

../core/../../../juce/JuceLibraryCode/modules/juce_audio_basics/../juce_core/containers/juce_HashMap.h: In static member function ‘static HandlerBase::CmdList FoomaticHandler::createCmdMapping()’:
 ../core/../../../juce/JuceLibraryCode/modules/juce_audio_basics/../juce_core/containers/juce_HashMap.h:445:5: error: ‘juce::HashMap::HashMap(const juce::HashMap&) [with KeyType = juce::String, ValueType = bool (HandlerBase::*)(BazCommand&), HashFunctionToUse = juce::DefaultHashFunctions, TypeOfCriticalSectionToUse = juce::DummyCriticalSection, juce::HashMap = juce::HashMap]’ is private
 FoomaticHandler.cpp:77:16: error: within this context

What is the right way to create such a static string -> member function mappings? And can the createCmdList() be made pure virtual to enforce implementation?

0
ajouté édité
Vues: 1
Désolé, c'est juste une réduction de code maladroite. Je vais regarder std :: function .
ajouté l'auteur Inductiveload, source
Vous ne semblez pas avoir de définition pour packetHandler, et vous utilisez des concepts dans FoomaticHandler qui sont définis dans HandlerBase même si vous n'en héritez pas. Essayez de regarder std :: function pour lier vos appels de méthode de manière standard.
ajouté l'auteur woolstar, source

Il n'y a pas de réponses.

0