std ::成員函數指針的映射？

Question

我需要實現std::map和<std::string, fn_ptr>對。函數指針是指向擁有該映射的同一類的方法的指針。這個想法是直接訪問這些方法，而不是實現一個交換機或等價物。

（我使用std::string作爲地圖鍵）

我很新的C++，所以任何人都可以張貼在談論實施與函數指針地圖的一些僞代碼或鏈接？ （指向擁有地圖的同一類所擁有的方法的指針）

如果您認爲對我的問題有更好的方法，建議也歡迎。

Answer 1

這是關於最簡單的我可以想出。注意沒有錯誤檢查，並且地圖可能有用地變爲靜態的。

#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

模板實現可能看起來像：

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

這就要求值用於確定哪些newA被稱爲在編譯時是已知的。您可以使用const char *作爲模板參數，但不能保證適用於所有編譯器。

另一種選擇是創建助手工廠，每個工廠創建方法一個，並將其存儲在地圖中。這與存儲方法指針相比並不是一個巨大的優勢，但它可以讓你定義一個默認的創建方法，並簡化從地圖獲取東西（不需要檢查關鍵是否存在，因爲你會得到一個默認工廠）。缺點是，每個未知密鑰的條目都會添加到地圖中。

此外，如果使用enum而不是字符串作爲鍵類型，則不需要擔心檢查映射中是否存在鍵。雖然有人可能會通過一個無效的enum鍵到newA，但他們必須明確地提出這個論點，這意味着他們不會偶然這樣做。我很難想象一個有人會故意導致newA崩潰的案例;潛在的場景涉及安全性，但應用程序員可能會在不使用類的情況下崩潰應用程序。

Answer 3

另一種選擇是使用代表作爲反對功能指針。 This委託實現相當快，支持多態，並與stl容器配合使用。 你可能有這樣的事情：

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

由於C++ 14中，我們可以使用一個通用的λ得到輕鬆指針出手成員方法。
它遵循一個通用的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{}); 
}