如何散列和比较指向成员函数的指针？

Question

我如何散列（std::tr1::hash 或 boost::hash）c++ 成员函数指针？

示例：

我有几个 bool (Class::*functionPointer)() （非静态）指向类 Class 的几个不同方法，我需要对这些指向成员函数的指针进行哈希处理。

我怎样才能做到这一点？

另外，我如何比较（std::less）这些成员函数指针，以便将它们存储在 std::set 中？

Answer 1

所有 C++ 对象（包括指向成员函数的指针）在内存中都表示为字符数组。所以你可以尝试：

bool (Class::*fn_ptr)() = &Class::whatever;
const char *ptrptr = static_cast<const char*>(static_cast<const void*>(&fn_ptr));

现在将 ptrptr 视为指向 (sizeof(bool (Class::*)())) 字节数组，并对这些字节进行散列或比较。如果您愿意，可以使用 unsigned char 代替 char。

这保证了没有误报 - 在 C++03 中，指向成员函数的指针是 POD，这意味着它们可以使用 memcpy 进行复制。这意味着如果逐字节值相同，则它们是相同的。

问题在于，成员函数指针的存储表示可能包括不参与该值的位，因此对于指向同一成员函数的不同指针，它们不一定相同。或者，由于某种模糊的原因，编译器可能有不止一种方法来指向同一类的相同函数，而这些方法在字节上并不相等。无论哪种方式，你都可能得到假阴性。您必须研究成员函数指针在您的实现中实际如何工作。它必须以某种方式实现成员函数指针的operator==，如果你能找出如何实现，那么你可能就能找出一个顺序和一个哈希函数。

这可能很困难：成员函数指针很尴尬，并且根据指向的函数类型（虚拟的、继承的），存储可能包含不同数量的非参与“闲置空间”。因此，您可能必须与编译器的实现细节进行大量交互。本文可能会帮助您入门：http://www.codeproject.com/KB/cpp /FastDelegate.aspx

一个更简洁的替代方案可能是通过数组进行线性搜索，以便“规范化”所有函数指针，然后根据该函数指针的“规范”实例的位置进行比较和散列在你的数组中。取决于你的性能要求是什么。而且即使有要求，类（及其派生类）是否有如此多的函数以至于线性搜索需要那么长时间？

typedef bool (Class::*func)();
vector<func> canon;

size_t getIndexOf(func fn_ptr) {
    vector<func>::iterator it = find(canon.begin(), canon.end(), fn_ptr);
    if (it != canon.end()) return it - canon.begin();
    canon.push_back(func);
    return canon.size() - 1;
}

Answer 2

我无法转换指针（在 Microsoft 编译器 2010 中），如前面的答案中所述，但这对我有用：

static string fmptostr(int atype::*opt)
  {
      char buf[sizeof(opt)];
      memcpy(&buf,&opt,sizeof(opt));
      return string(buf,sizeof(opt));
  }

关于指针的按位标识，它可以是按位的，因此看起来是否使用了适当的编译器开关。至少对于微软编译器来说是这样的
使用#pragmapointers_to_members
和一个开关.../vmg

Answer 3

如果您的成员函数指针是唯一的（在大多数情况下对于基于回调的订阅都是如此），那么您可以使用带有 type_index，其唯一性是通过程序中类型（即Class::Method）的唯一性来保证的，适合存储在unordered_map，

struct MyEvent {

    using fn_t = std::function<void(MyEvent &)>;
    using map_t = std::unordered_map<std::type_index, fn_t>;


    template <typename Handler>
    void subscribe(Object& obj, Handler&& handler) {
        fn_t fn = [&, handler = std::move(handler)](MyEvent& event) {
            (obj.*handler)(event);
        }
        std::type_index index = typeid(Handler);
        subscribers.emplace(std::move(index), std::move(fn));
    }

    void fire() {
        for(auto& pair: subscribers) {
            auto& fn = pair.second;
            fn(*this);
        }
    }

    map_t subscribers;
}

即订阅和触发事件示例：

MyEvent event;
MyObject obj = ...;
event.subscribe(obj, &MyObject::on_event );
...
event.fire();

因此，上面的示例为您提供了类/方法唯一性，如果您需要对象/方法唯一性，那么您应该有一个结构，它提供组合哈希，假设有 std::hash 并且已经有 std::hash 用于成员函数指针。