एक QSet <SomeClass*> कंटेनर के लिए qHash कैसे लिखें?

Question

मुझे अपने आवेदन में सेट का एक सेट लागू करने की आवश्यकता है। कस्टम क्लास के साथ क्यूसेट का उपयोग करने के लिए qHash() फ़ंक्शन और operator== प्रदान करना आवश्यक है।

class Custom{ 
     int x; 
     int y; 
     //some other irrelevant here 
    } 
    inline uint qHash(Custom* c){ 
     return (qHash(c->x)^qHash(c->y)); 
    } 
    bool operator==(Custom &c1, Custom &c2){ 
     return ((c1.x==c2.x) && (c1.y == c2.y)); 
    } 

    //now I can use: QSet<Custom*> 

मैं qHash(QSet<Custom*>) कैसे लागू कर सकते हैं, QSet< QSet<SomeClass*> > उपयोग करने के लिए सक्षम होने के लिए:

कोड इस प्रकार है?

संपादित करें:

अतिरिक्त प्रश्न: अपने आवेदन में "सेट के सेट" अप करने के लिए 15000 सेट हो सकते हैं। 25 कस्टम क्लास पॉइंटर्स तक प्रत्येक सबसेट। कैसे गारंटी है कि qHash(QSet<Custom*>) पर्याप्त अद्वितीय होगा?

Answer 1

एक आम तरीका कंटेनर हैश करने के लिए सभी तत्वों के हैश गठबंधन करने के लिए है। बूस्ट इस उद्देश्य के लिए hash_combine and hash_range प्रदान करता है। यह आपको अपने qHash के परिणामों के लिए इसे कार्यान्वित करने का विचार देना चाहिए।

uint qHash(const QSet<Custom*>& c) { 
    uint seed = 0; 

    for(auto x : c) { 
    seed ^= qHash(x) + 0x9e3779b9 + (seed << 6) + (seed >> 2); 
    } 

    return seed; 
} 

Answer 2

आप boost::hash_range/boost::hash_combine (जो क्या PMR का जवाब होता है, प्रभावी रूप से), क्योंकि QSetstd::unordered_set के क्यूटी बराबर है, और, के रूप में के साथ qHash लागू नहीं कर सकते:

तो, अपने qHashCustom के लिए दिया एसटीएल नाम से पता चलता है, इन कंटेनरों अव्यवस्थित हैं, जबकि Boost Documentation कहा गया है कि hash_combine क्रम पर निर्भर है, यानी। यह अलग हैश मानों के लिए हैश क्रमपरिवर्तन होगा।

:

यह एक समस्या आप गारंटी नहीं दे सकते कि दो सेट है कि बराबर की तुलना कर रहे हैं वास्तव में, बराबर है, जो एक हैश समारोह की आवश्यकताओं में से एक है क्योंकि अगर आप भोलेपन से संग्रहीत क्रम में तत्वों हैश गठबंधन है

For all x, y: x == y => qHash(x) == qHash(y) 

इसलिए, यदि आपके हैश-संयोजन फ़ंक्शन को इनपुट मानों के किसी भी क्रमपरिवर्तन के लिए समान आउटपुट उत्पन्न करने की आवश्यकता है, तो इसे कम्यूटेटिव होना चाहिए।

template <typename T> 
inline uint qHash(const QSet<T> &set, uint seed=0) { 
    return std::accumulate(set.begin(), set.end(), seed, 
          [](uint seed, const T&value) { 
           return seed + qHash(value); // or^
          }); 
}