只要我能为我的类型提供hasher函数，为什么我需要为我的类型专门设置std：：hash？

Question

我已经实现了这个示例：

class Foo;
template<>
class std::hash<Foo>;

class Foo
{
public:
    Foo(std::string const& s, int x) : str_(s), x_(x){}
    std::string str()const {return str_;}
    int get_x() const{ return x_;}

private:
    std::string str_;
    int x_{};
    friend bool operator==(Foo const&, Foo const&);
    friend class std::hash<Foo>;
};

bool operator==(Foo const& lhs, Foo const& rhs)
{
    return lhs.str_ == rhs.str_ && lhs.x_ == rhs.x_;
}

size_t hasher(Foo const& f)
{
    return std::hash<std::string>()(f.str()) ^
            std::hash<int>()(f.get_x());
}

namespace std
{
    template <>
    class hash<Foo>
    {
    public:
        using argument_type = Foo;
        using result_type = std::size_t;
        result_type operator()(argument_type const& a)const;
    };

    typename hash<Foo>::result_type
    hash<Foo>::operator()(argument_type const& a)const
    {
        return hash<std::string>()(a.str_) ^
                hash<int>()(a.x_);
    }
}

int main()
{

    std::unordered_set<Foo, decltype(hasher)*> u(5, hasher); // needs hasher as template argument and as function argument
    u.insert(Foo{"hi", 100});

    std::unordered_set<Foo> u2; // doesn't need either
    u2.insert(Foo("hi", 100));

    std::cout << "\ndone!\n";
}

>

如果我运行程序，程序编译和工作都很好。正如您所看到的，我的hasher函数与调用运算符中的功能相同，它是std::hash 专门化的成员函数，那么为什么我专门化后一个std::hash而可以提供简单的hasher函数呢？

那是为了灵活性吗？例如，为我的foo类型提供hasher函数而不是专门化std::hash类型，需要在关联容器实例化中指定为模板参数和函数参数，比如unordered_set，而后者不需要？

Answer 1

只要我可以为我的类类型提供hasher，为什么我[我需要]专门化std::hash ？

你不需要。无论如何，这里有一些这样做的理由：

>

如果您的类是API的一部分（内部或外部都无关紧要），并且希望为类的用户提供将其用作无序容器中的键的可能性（或者出于任何其他原因，对其进行哈希），友好的方法是专门化std::hash。没有人会期望必须指定一个特殊的函数来为可哈希的类型（可能被记录为）进行哈希。

一旦编写了专门化，就不需要免费的哈希函数了，所以如果上面的任何一个似乎适用，就可以立即专门化std::hash（并完全跳过免费哈希函数）。

使样板更短的一种方法是使用struct而不是class对其进行专门化。主类模板是

namespace std {
    template<class Key>
    struct hash;
}

所以这样做也是完全有意义的。您的定义是：

namespace std {
    struct hash<Foo> {
        using argument_type = Foo;
        using result_type = std::size_t;
        result_type operator()(argument_type const& a) const;
    };
}