cpp unordered_set just use comparator not hash

Question

#include <unordered_set>
#include <iostream>

class edge{
    public:
        float a1;
        float a2;

};

struct comp{
    bool operator()(const edge& e1, const edge& e2) const {
        return true;
        return (
            (e1.a1==e2.a1 && e1.a2==e2.a2) ||
            (e1.a1==e2.a2 && e1.a2==e2.a1)
        );
    };
};
struct hash{
    size_t operator()(const edge& e1) const {
        // return std::hash<float>()(e1.a1+e1.a2);
        return std::hash<float>()(e1.a1+e1.a2*2);
    };
};


int main() {
    std::unordered_set<edge,hash,comp> s1;
    s1.insert(edge{1.1,2.2});
    s1.insert(edge{2.2,1.1});
    for( auto& it : s1 ) {
        std::cout << it.a1 << " " << it.a2 << "\n";
    }
    std::cout << "s1.size " << s1.size() << "\n";
}

I realize that if different element has same hash value, then they are considered equal, but I just want this unordered_set use comparator that I define, just ignore hash?

How to achieve that?

I know i can use set, but using set need to consider order, if a < b is true and b < a is also true, then this element will not be inserted successfully, Sometimes, It is hard to provide order.

If anyone can help, much appreciated

---

edited: My intention is to let two edges called e1,e2, they are same if (e1.a1==e2.a1&&e1.a2==e2.a2)or(e1.a1==e2.a2 && e1.a2==e2.a1) as I provided in struct comp. but when i test. it seems hash function can change the comparison too. Someone says the way I define hash and comparator result in undefined behaviour. Is that true? why? if true, how to solve this? I just want comparator decide which one is satisfied to be inserted in unordered_set without duplicate. And really do not care about hash.

BTW, thanks for some many people replying

Answer 1

If you want to handle edge.a1 and edge.a2 interchangeably, you have to implement a hashing function that returns the same value even when they are swapped. I advise against using addition, because addition may not be commutative for floats, but you could sort them by size and combine the hashes afterwards:

struct hash {
  size_t operator()(const edge& e1) const {
    auto h1 = std::hash<float>{}(std::min(e1.a1, e1.a2));
    auto h2 = std::hash<float>{}(std::max(e1.a1, e1.a2));
    return h1 ^ (h2 << 1)
  };
};

This only makes sense for pretty large sets of floats, because otherwise the hashing overhead probably exceeds the benefit of using a hashed data structure in the first place.

Old answer for reference:

Objects with the same hash are not considered equal in unordered_set. They are just stored in the same bucket. There is a KeyEqual template parameter for the comparison, which by default uses the operator== of your Key. So your main problem is, that comp should implement e1 == e2 and not e1 < e2 (and should probably be called equal).

The hash is just used to speed up the search, insertion, and removal of elements.

On another note, you may want to use the hashes of the member variables instead of the values themselves to compute the hash of edge:

struct hash {
  size_t operator()(const edge& e1) const {
    auto h1 = std::hash<float>{}(e1.a1);
    auto h2 = std::hash<float>{}(e1.a2);
    return h1 ^ (h2 << 1)
  };
};

This way, you won't get the same hash for two edges with swapped coordinates. This way of combining hashes is suggested here (but is not a good way to combine more than two).

Answer 2

You don't have to use the members of edge to provide the hash. It is only required that equal values have equal hashes. A "always valid" hash is

struct hash{
    size_t operator()(const edge& e1) const {
        return 0;
    };
};

But it seems your original attempt is better

struct hash{
    size_t operator()(const edge& e1) const {
        return std::hash<float>{}(e1.a1 + e1.a2); // + is commutative
    };
};