如何在不编写自定义哈希函数的情况下使用元组作为无序映射中的键？

在没有自定义哈希函数的无序映射中使用元组

您可能期望 std::unordered_map 能够轻松地使用开箱即用的元组键。然而，它需要为元组定义一个哈希函数，如下所示：

template struct do_hash<tuple int>> {
    size_t operator()(std::tuple<int int> const& tt) const {...}
};</int></tuple>

这个过程可能会变得乏味，导致在不诉诸可变参数模板的情况下为 C 0x 元组实现自动化的问题。

以下方法允许所有包含标准可哈希类型的 C 0x 元组成为 unordered_map 和 unordered_set 的一部分，而无需额外的努力：

#include <tuple>
namespace std {
    namespace {
        template <class t>
        inline void hash_combine(std::size_t& seed, T const& v) {
            // Modified from Boost
            seed ^= std::hash<t>()(v) + 0x9e3779b9 + (seed > 2);
        }

        // Recursive template for hashing tuples
        template <class tuple size_t index="std::tuple_size<Tuple">::value - 1>
        struct HashValueImpl {
            static void apply(size_t& seed, Tuple const& tuple) {
                HashValueImpl<tuple index>::apply(seed, tuple);
                hash_combine(seed, std::get<index>(tuple));
            }
        };

        template <class tuple>
        struct HashValueImpl<tuple> {
            static void apply(size_t& seed, Tuple const& tuple) {
                hash_combine(seed, std::get(tuple));
            }
        };
    }

    template <typename... tt>
    struct hash<:tuple>> {
        size_t
        operator()(std::tuple<tt...> const& tt) const {
            size_t seed = 0;
            HashValueImpl<:tuple>>::apply(seed, tt);
            return seed;
        }
    };
}</:tuple></tt...></:tuple></typename...></tuple></class></index></tuple></class></t></class></tuple>

通过将函数放置在 std 命名空间中，可以通过参数访问它 -依赖名称查找 (ADL)。

标准一致性代码

专门化 std 命名空间中的对象是未定义的行为。因此，对于符合标准的解决方案，请将代码移动到单独的命名空间中并放弃 ADL 的便利性：

namespace hash_tuple {

// Forward non-tuple types to std::hash
template <class tt>
struct hash {
    size_t
    operator()(TT const& tt) const {
        return std::hash<tt>()(tt);
    }
};

// Hash function combining values in a tuple
template <class tuple size_t index="std::tuple_size<Tuple">::value - 1>
struct HashValueImpl {
    static void apply(size_t& seed, Tuple const& tuple) {
        HashValueImpl<tuple index>::apply(seed, tuple);
        hash_combine(seed, std::get<index>(tuple));
    }
};

template <class tuple>
struct HashValueImpl<tuple> {
    static void apply(size_t& seed, Tuple const& tuple) {
        hash_combine(seed, std::get(tuple));
    }
};

// Hash function for tuples
template <typename... tt>
struct hash<:tuple>> {
    size_t
    operator()(std::tuple<tt...> const& tt) const {
        size_t seed = 0;
        HashValueImpl<:tuple>>::apply(seed, tt);
        return seed;
    }
};
} // namespace hash_tuple</:tuple></tt...></:tuple></typename...></tuple></class></index></tuple></class></tt></class>

在 hash_tuple 命名空间中声明一个哈希实现，以将所有非元组类型转发到 std： :hash 并修改 hash_combine 以使用 hash_tuple::hash 而不是 std::hash。将剩余的代码放在 hash_tuple 命名空间中。

要使用此解决方案，必须包含以下代码，这会放弃 ADL 的便利性：

unordered_set<tuple int>, hash_tuple::hash<tuple int>>> test2;</tuple></tuple>

以上是如何在不编写自定义哈希函数的情况下使用元组作为无序映射中的键？的详细内容。更多信息请关注PHP中文网其他相关文章！