Stocker des pointeurs vers une fonction membre dans la carte

Semble bien pour moi, mais pour le fait que descrToFuncMap doit être déclaré static si vous avez l'intention de l'initialiser à partir de l'intérieur de la fonction statique Initialize().

Si vous voulez vous assurer que Initialize() est appelée, et est appelée qu'une fois, vous pouvez utiliser le pattern Singleton. En gros, si vous ne faites pas le multithreading, qui signifie que tout emballage descrToFuncMap à l'intérieur de sa propre classe (appelée dire FuncMap) avec un constructeur privé qui appelle Initialize(). Ensuite, vous ajoutez un static variable locale de type FuncMap à Processor::Process() -- parce que la variable est static, il persiste et n'est initialisé une fois.

Exemple de code (je me rends compte maintenant que friend n'est pas vraiment nécessaire ici):

class Processor {
private:
    typedef double (MyClass::*MemFuncGetter)();

    class FuncMap {
    public:
        FuncMap() {
            descrToFuncMap["X"]=&MyClass::GetX;
            descrToFuncMap["SomethingElse"]=&MyClass::GetSomethingElse;
            descrToFuncMap["RR"]=&MyClass::GetRR;
            descrToFuncMap["T"]=&MyClass::GetT;
        }

        //Of course you could encapsulate this, but its hardly worth
        //the bother since the whole class is private anyway.
        map<std::string, MemFuncGetter> descrToFuncMap;
    };

public:
    void Process(Myclass m, string);
};

void Processor::Process(MyClass ms, const std::string& key) {
    static FuncMap fm;      //Only gets initialised on first call
    map<std::string, Getter>::iterator found=fm.descrToFuncMap.find(key);
    if(found!=fm.descrToFuncMap.end()) {
        MemFuncGetter memFunc=found->second;
        double dResult=(ms).*memFunc();    
        std::cout<<"Command="<<key<<", and result="<<result<<std::end;      
    }
}

Ce n'est pas le "vrai" pattern Singleton comme les diverses fonctions pourraient créer leur propre, distincte des instances de FuncMap, mais c'est assez pour ce que vous avez besoin. Pour les "vrais" Singleton, vous pouvez déclarer des FuncMap'constructeur privé et ajouter une méthode statique, dire getInstance(), qui a défini le seul et unique instance comme un static variable et est retourné référence à cela. Processor::Process() serait alors l'utiliser avec

FuncMap& fm = FuncMap::getInstance();

OriginalL'auteur j_random_hacker

Éviter l'utilisation de "virtuel" si vous utilisez des cartes de pointeurs de fonction. Dans ce contexte, à l'aide de "virtuel" mot-clé ne va pas aider beaucoup. Par exemple

descrToFuncMap["X"]=&MyClass::GetX;

sera toujours appeler 'Maclasse::GetX fonction, même si GetX est remplacée par la classe dérivée de MyClass.

Habituellement, vous n'aurez pas grand nombre de fonctions dans la classe, plutôt que d'utiliser la carte, vous pouvez créer simple struct tableau et utiliser une boucle for. Si le nombre de fonctions sont de petite taille, il n'y aura pas une grosse différence de performances de la carte et le tableau. Quelque chose de similaire au code ci-dessous

class  MyClass
{
   //........
   double GetX();
   double GetSomethingElse();
   double GetT();
   double GetRR();
   //........
};

typedef double (MyClass::*MemFuncGetter)();

struct FuncTable
{
    const char* m_pFuncName;
    MemFuncGetter m_pFuncPtr;
};

class Processor
{          
 public:
        void Process(Myclass& m, string);
};

static FuncTable descrToFuncMap[]
{
    { "X",  &MyClass::GetX},
    { "SomethingElse", &MyClass::GetSomethingElse },
    { "RR", &MyClass::GetRR},
    { "T", &MyClass::GetT}
};

void Processor::Process(MyClass& ms, const std::string& key)
{
    int functablesize = sizeof(descrToFuncMap)/sizeof(descrToFuncMap[0])

    for(int i=0; i< functablesize; ++i)
    {   
        if( strcmp(key.c_str(), descrToFuncMap[i].m_pFuncName)==0)
        {
            MemFuncGetter memFunc=descrToFuncMap[i].m_pFuncPtr;
            double dResult=(ms).*memFunc();    
            std::cout<<"Command="<<key<<"result="<<result<<std::end;
            break;
        }
    }     
 }

OriginalL'auteur Nitin Bhide