Resolved: How do I write a hash function for an unordered_map that takes a pair as key, but return the same value if I switch the order of the pairs members?

std::pair<int,int> p1 = std::make_pair<3,4>;
std::pair<int,int> p2 = std::make_pair<4,3>;
std::unordered_map<std::pair<int,int>, int> m;
m[p1] = 3;
// m[p2] should now also return 3!

#include <vector><br />
#include <string><br />
#include <iostream><br />
#include <algorithm><br />
#include <memory><br />
#include <unordered_map><br />
#include <functional></p>
<p>class Point<br />
{<br />
public:<br />
    static size_t id_counter;<br />
    size_t id;<br />
    Point()=default;<br />
    ~Point()=default;<br />
    bool operator==(const Point& rhs)<br />
    {<br />
        return id == rhs.id;<br />
    }<br />
    friend std::ostream& operator<<(std::ostream& os, Point& P);
};
size_t Point::id_counter = 0;

class Hasch_point_pair
{
public:
    size_t operator()(const std::pair<Point*, Point*>* p) const<br />
    {<br />
        // XOR hash. We don't care about collision we're FREAKS<br />
        auto h1 = std::hash<size_t>()(p->first->id);<br />
        auto h2 = std::hash<size_t>()(p->second->id);<br />
        return h1^h2;<br />
    }<br />
};</p>
<p>int main(int argc, char const *argv[])<br />
{<br />
    auto p1 = std::make_unique<Point>();<br />
    auto p2 = std::make_unique<Point>();<br />
    auto p3 = std::make_unique<Point>();<br />
    auto p4 = std::make_unique<Point>();<br />
    std::unordered_map<std::pair<Point*, Point*>*, size_t*, Hasch_point_pair> m;<br />
    auto p  = std::make_unique<std::pair<Point*, Point*>>(p1.get(),p2.get());<br />
    auto p_hmm  = std::make_unique<std::pair<Point*, Point*>>(p2.get(),p1.get());<br />
    size_t value = 3;<br />
    m[p.get()] = &value;<br />
    std::cout << "m[p] = " << m.at(p.get()) << std::endl;
    std::cout << "m[p_hmm] = " << m.at(p_hmm.get()) << std::endl;
}
[/code]

</p>



One thought I had was to compare the id's of each Point and always use the Point with the largest id member variable as the first hash, but I haven't gotten it to work. Does it make sense?<br> 


<p>[code]class Hasch_point_pair<br />
{<br />
public:<br />
    size_t operator()(const std::pair<Point*, Point*>* p) const<br />
    {<br />
        if (p->first->id > p->second->id)<br />
        {<br />
            auto h1 = std::hash<size_t>()(p->first->id);<br />
            auto h2 = std::hash<size_t>()(p->second->id);<br />
            return h1^h2;<br />
        }<br />
        else<br />
        {<br />
            // Note switched order of hash1 and hash2!<br />
            auto h2 = std::hash<size_t>()(p->first->id);<br />
            auto h1 = std::hash<size_t>()(p->second->id);<br />
            return h1^h2;<br />
        }<br />
    }<br />
};

class Equal_point_pair
{
public:
    bool operator(
        const std::pair<Point *, Point *> p1, 
        const std::pair<Point *, Point *> p2) const
    {
        // Verify if both pair are in the same order
        const bool p1Asc = p1->first-> id < p1->second-> id;
        const bool p2Asc = p2->first-> id < p2->second-> id;

        // If both point are in same order, compare same members
        // Otherwise, compare swaped members...
        return p1Asc == p2Asc ? 
            *p1->first == *p2->first && *p1->second == *p2->second :
            *p1->first == *p2->second && *p1->second == *p2->first;
    }
};

using PointMap = std::unordered_map<
    std::pair<Point*, Point*>*, 
    size_t*, 
    Hasch_point_pair,
    Equal_pointPair>;

PointMap m;