Làm thế nào để đặc biệt hóa std :: hash <Key> :: operator () cho kiểu do người dùng xác định trong các vùng chứa không có thứ tự?

Để hỗ trợ các loại khóa do người dùng xác định trong std::unordered_set<Key>và std::unordered_map<Key, Value> người ta phải cung cấp operator==(Key, Key)và một bộ chức năng băm:

struct X { int id; /* ... */ };
bool operator==(X a, X b) { return a.id == b.id; }

struct MyHash {
  size_t operator()(const X& x) const { return std::hash<int>()(x.id); }
};

std::unordered_set<X, MyHash> s;

Sẽ thuận tiện hơn nếu chỉ viết std::unordered_set<X> với một hàm băm mặc định cho kiểu X, như cho các kiểu đi kèm với trình biên dịch và thư viện. Sau khi tư vấn

• Bản nháp tiêu chuẩn C ++ N3242 §20.8.12 [unard.hash] và §17.6.3.4 [hash.requirements],
• Boost.Unordered
• g ++ include\c++\4.7.0\bits\functional_hash.h
• VC10 include\xfunctional
• các câu hỏi liên quan khác nhau trong Stack Overflow

có vẻ như có thể chuyên môn hóa std::hash<X>::operator():

namespace std { // argh!
  template <>
  inline size_t 
  hash<X>::operator()(const X& x) const { return hash<int>()(x.id); } // works for MS VC10, but not for g++
  // or
  // hash<X>::operator()(X x) const { return hash<int>()(x.id); }     // works for g++ 4.7, but not for VC10 
}                                                                             

Hỗ trợ trình biên dịch cho C ++ 11 vẫn chưa được thử nghiệm --- Tôi đã không thử Clang ---, đây là những câu hỏi của tôi:

1. Việc thêm một chuyên ngành như vậy vào không gian tên có hợp pháp không std? Tôi có cảm xúc lẫn lộn về điều đó.

2. std::hash<X>::operator()Phiên bản nào trong số các phiên bản, nếu có, tuân thủ tiêu chuẩn C ++ 11?

3. Có một cách di động để làm điều đó?

Bạn được phép rõ ràng và được khuyến khích thêm chuyên môn vào không gian tên std*. Cách chính xác (và về cơ bản là duy nhất) để thêm hàm băm là:

namespace std {
  template <> struct hash<Foo>
  {
    size_t operator()(const Foo & x) const
    {
      /* your code here, e.g. "return hash<int>()(x.value);" */
    }
  };
}

(Các chuyên môn phổ biến khác mà bạn có thể cân nhắc hỗ trợ std::less, std::equal_tovà std::swap.)

_{*) miễn là một trong các loại liên quan do người dùng xác định, tôi cho là vậy.}

Đặt cược của tôi sẽ là đối số mẫu băm cho các lớp unardered_map / unorder_set / ...:

#include <unordered_set>
#include <functional>

struct X 
{
    int x, y;
    std::size_t gethash() const { return (x*39)^y; }
};

typedef std::unordered_set<X, std::size_t(*)(const X&)> Xunset;
typedef std::unordered_set<X, std::function<std::size_t(const X&)> > Xunset2;

int main()
{
    auto hashX = [](const X&x) { return x.gethash(); };

    Xunset  my_set (0, hashX);
    Xunset2 my_set2(0, hashX); // if you prefer a more flexible set typedef
}

Tất nhiên

• hashX cũng có thể là một hàm tĩnh toàn cầu
• trong trường hợp thứ hai, bạn có thể vượt qua điều đó
  • đối tượng functor cũ ( struct Xhasher { size_t operator(const X&) const; };)
  • std::hash<X>()
  • bất kỳ biểu thức ràng buộc nào thỏa mãn chữ ký -

@Kerrek SB đã bao gồm 1) và 3).

2) Mặc dù g ++ và VC10 khai báo std::hash<T>::operator()với các chữ ký khác nhau, cả hai triển khai thư viện đều tuân thủ Tiêu chuẩn.

Tiêu chuẩn không chỉ định các thành viên của std::hash<T>. Nó chỉ nói rằng mỗi chuyên ngành như vậy phải đáp ứng cùng một yêu cầu "Hash" cần thiết cho đối số mẫu thứ hai std::unordered_set, v.v. Cụ thể:

• Kiểu băm Hlà một đối tượng hàm, có ít nhất một kiểu đối số Key.
• H là bản sao có thể xây dựng.
• H là có thể phá hủy.
• Nếu hlà một biểu thức của kiểu Hhoặc const Hvà klà một biểu thức của kiểu có thể chuyển đổi thành (có thể const) Key, thì h(k)là một biểu thức hợp lệ với kiểu size_t.
• Nếu hlà một biểu thức của kiểu Hhoặc const Hvà ulà giá trị của kiểu Key, thì đó h(u)là một biểu thức hợp lệ với kiểu size_tkhông sửa đổi u.