定义哈希函数的C++20概念

Question

在cppreference上，有一个示例定义了概念hashable。我复制了下面的示例：

template<typename T>
concept Hashable = requires(T a) {
    { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
};

这个hashable概念对许多用途都有意义。在这些情况下，t类型的对象上的哈希函数是专门化std::hash 。但是，出于我的目的，我不想假设哈希将是std::Hash 。我希望用户能够提供一个不同的哈希函数。

由于hashfunc和key绑定得如此紧密，所以我不认为可以为hashfunc和key定义单独的概念。那是正确的吗？因此，我想定义一个概念hashconcept，它同时处理hashfunc和key。

null

template<typename HashFunc, typename Key>
concept Hash = requires(HashFunc h, Key k) {
    { std::invoke(h, k) } -> std::convertible_to<std::size_t>;
};

#include <functional>
#include <concepts>
#include <iostream>

template<typename HashFunc, typename Key>
concept HashConcept = requires(HashFunc h, Key k) {
    { std::invoke(h, k) } -> std::convertible_to<std::size_t>;
};


class HashFunc {
public:
    std::size_t operator()(int i) {
        return static_cast<size_t>(i);
    }
};

template<typename Hash, typename Key>
    requires HashConcept<Hash, Key>
size_t HashConceptUser(Hash h, Key k) {
    return h(k);
}

int main() {
    std::cout << HashConceptUser< HashFunc, int >(HashFunc{}, 3); 

}

Answer 1

这个列表看起来完整吗？

该列表可能缺少哈希函数最重要的一个条件：如果a==b，则h(a)==h(b)。

列表中的第4个标准是好的哈希函数所需要的，它本身有些不完整--你不仅希望碰撞的可能性很小，还希望随机分散。hash函数h(i)=i满足第4个准则，但不是一个好的hash函数。另一方面，h(i)=0是一个糟糕的哈希函数，但应该被认为是有效的。

template <typename F, typename T>
concept HashFor = std::regular_invocable<F, T>
               && std::convertible_to<std::invoke_result_t<F, T>, size_t>;

template <typename F, typename T>
concept HashFor = std::regular_invocable<F, T>
    && requires(F f, T t) {
        { std::invoke(f, t) } -> std::convertible_to<size_t>;
    };