如何为绑定自由函数或成员函数的std::function生成唯一哈希？

问题根源 #

std::function::target<T>()仅能匹配存储的精确类型：

• 绑定自由函数时，std::function存储的是函数指针，因此target<void(*)(const Message&, Error)>()能拿到有效指针；
• 用std::bind绑定成员函数时，std::function实际存储的是std::bind生成的匿名闭包对象，而非成员函数指针，所以target<成员函数指针类型>()会返回nullptr，无法通过它生成哈希。

解决方案 #

1. 基于std::function内部实例的哈希（无需调用者修改代码）

如果你的需求是区分不同的std::function实例（即使语义相同的绑定，不同实例也有不同哈希），可以结合target_type()和target()生成哈希：

#include <functional>
#include <typeindex>
#include <cstddef>

std::size_t hash_function(const std::function<void(const Message&, Error)>& func) {
    if (!func) return 0;

    // 结合类型信息哈希和目标实例地址哈希
    const auto type_hash = std::hash<std::type_index>()(std::type_index(func.target_type()));
    const auto ptr_hash = std::hash<const void*>()(func.target());
    
    // 组合哈希（可根据需求调整逻辑，比如相加、移位异或）
    return type_hash ^ (ptr_hash << 1);
}

优缺点：

• ✅ 无需调用者修改现有绑定代码；
• ❌ 语义相同的绑定（比如两次std::bind同一个成员函数+同一个对象）会生成不同哈希，因为每次std::bind都会生成新的闭包实例。

2. 自定义包装器（可控哈希逻辑，需调用者配合）

如果需要语义一致的绑定生成相同哈希，可以自定义包装器统一处理自由函数和成员函数的绑定，在包装时计算并存储哈希：

#include <functional>
#include <cstddef>

// 针对目标签名的包装器特化
struct HashableFunc {
    std::function<void(const Message&, Error)> impl;
    std::size_t hash_val;

    // 包装自由函数
    explicit HashableFunc(void(*func)(const Message&, Error))
        : impl(func), hash_val(std::hash<decltype(func)>()(func)) {}

    // 包装成员函数+对象指针
    template<typename T>
    HashableFunc(T* obj, void(T::*func)(const Message&, Error))
        : impl([obj, func](const Message& msg, Error err) { (obj->*func)(msg, err); }) {
        // 组合对象地址和成员函数指针的哈希
        hash_val = std::hash<T*>()(obj) ^ std::hash<decltype(func)>()(func);
    }

    // 重载调用运算符
    void operator()(const Message& msg, Error err) const {
        impl(msg, err);
    }

    // 获取哈希
    std::size_t get_hash() const {
        return hash_val;
    }
};

使用方式：
调用者通过包装器生成std::function，不再直接用std::bind或裸函数：

// 绑定自由函数
std::function<void(const Message&, Error)> f1 = HashableFunc(&free_func);

// 绑定成员函数
Foo obj;
std::function<void(const Message&, Error)> f2 = HashableFunc(&obj, &Foo::member_func);

// 获取哈希
std::size_t hash1 = f1.target<HashableFunc>()->get_hash();
std::size_t hash2 = f2.target<HashableFunc>()->get_hash();

优缺点：

• ✅ 语义相同的绑定（同一成员函数+同一对象、同一自由函数）会生成相同哈希；
• ✅ 完全可控哈希逻辑；
• ❌ 需要调用者修改绑定代码，改用自定义包装器。

3. 直接使用C++20的std::hash特化

C++20起，标准库为std::function提供了std::hash特化，实现逻辑和方案1类似，直接使用即可：

std::size_t hash_val = std::hash<std::function<void(const Message&, Error)>>()(func);

注意：同样是基于实例的哈希，语义相同的不同实例哈希不同。

内容的提问来源于stack exchange，提问作者StoneThrow