จะเชี่ยวชาญ std :: hash <Key> :: operator () สำหรับชนิดที่ผู้ใช้กำหนดในคอนเทนเนอร์ที่ไม่ได้เรียงลำดับได้อย่างไร

ในการรองรับประเภทคีย์ที่ผู้ใช้กำหนดstd::unordered_set<Key>และstd::unordered_map<Key, Value> ต้องระบุoperator==(Key, Key)และแฮช functor:

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;

จะสะดวกกว่าในการเขียนstd::unordered_set<X> โดยใช้แฮชเริ่มต้นสำหรับประเภทXเช่นประเภทที่มาพร้อมกับคอมไพเลอร์และไลบรารี หลังจากปรึกษา

• C ++ Standard Draft N3242 §20.8.12 [unord.hash] และ§17.6.3.4 [hash.requirements],
• เพิ่มไม่เรียงลำดับ
• g ++ include\c++\4.7.0\bits\functional_hash.h
• VC10 include\xfunctional
• คำถามที่เกี่ยวข้องต่างๆใน Stack Overflow

ดูเหมือนจะเชี่ยวชาญ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 
}                                                                             

เนื่องจากการสนับสนุนคอมไพเลอร์สำหรับ C ++ 11 ยังเป็นการทดลอง - ฉันไม่ได้ลองเสียงดัง --- นี่คือคำถามของฉัน:

1. การเพิ่มความเชี่ยวชาญดังกล่าวให้กับเนมสเปซถูกกฎหมายstdหรือไม่? ฉันมีความรู้สึกหลากหลายเกี่ยวกับเรื่องนั้น

2. ซึ่งในstd::hash<X>::operator()รุ่นถ้ามีสอดคล้องกับ C ++ 11 มาตรฐาน?

3. มีวิธีทำแบบพกพาไหม

คุณได้รับอนุญาตอย่างชัดแจ้งและสนับสนุนให้เพิ่มความเชี่ยวชาญพิเศษให้กับเนมสเปซstd* วิธีที่ถูกต้อง (และโดยทั่วไปเท่านั้น) ในการเพิ่มฟังก์ชันแฮชคือ:

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

(เฉพาะยอดนิยมอื่น ๆ ที่คุณอาจพิจารณาสนับสนุนมีstd::less, std::equal_toและstd::swap.)

_{*) ตราบใดที่หนึ่งในประเภทที่เกี่ยวข้องถูกกำหนดโดยผู้ใช้ฉันคิดว่า}

เดิมพันของฉันคืออาร์กิวเมนต์แม่แบบแฮชสำหรับคลาส unordered_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
}

แน่นอน

• hashX อาจเป็นฟังก์ชันคงที่ทั่วโลกได้เช่นกัน
• ในกรณีที่สองคุณสามารถผ่านมันไปได้
  • วัตถุ functor สมัยเก่า ( struct Xhasher { size_t operator(const X&) const; };)
  • std::hash<X>()
  • นิพจน์ผูกใด ๆ ที่ตรงตามลายเซ็น -

@Kerrek SB ครอบคลุม 1) และ 3)

2) แม้ว่า g ++ และ VC10 จะประกาศstd::hash<T>::operator()ด้วยลายเซ็นที่ต่างกัน แต่การใช้งานไลบรารีทั้งสองก็เป็นไปตามมาตรฐาน

มาตรฐานไม่ได้ระบุสมาชิกของstd::hash<T>. เพียงแค่บอกว่าความเชี่ยวชาญแต่ละอย่างจะต้องเป็นไปตามข้อกำหนด "Hash" เดียวกันที่จำเป็นสำหรับอาร์กิวเมนต์แม่แบบที่สองstd::unordered_setเป็นต้น ได้แก่ :

• ประเภทกัญชาเป็นวัตถุที่ฟังก์ชั่นที่มีประเภทการโต้แย้งอย่างน้อยหนึ่งHKey
• H เป็นสำเนาที่สร้างสรรค์ได้
• H เป็นสิ่งที่ทำลายได้
• หากhคือการแสดงออกของประเภทHหรือconst Hและkคือการแสดงออกของชนิดแปลงสภาพที่ (อาจจะconst) Keyแล้วคือการแสดงออกที่ถูกต้องกับประเภทh(k)size_t
• หากhคือการแสดงออกของประเภทHหรือconst Hและuเป็น lvalue ประเภทKeyแล้วh(u)คือการแสดงออกที่ถูกต้องกับประเภทที่ไม่ได้ปรับเปลี่ยนsize_tu