为什么 operator< 包含自定义对象的 STL 集需要重载，而不是 operator==

Question

I'm working with C++11 and I want to use set to store my custom objects because I need a container, which can filter the elements with the same value.

Here is the class of my custom object:

struct Ele
{
    int a, b, c;
}

As my understanding, I need to overload the function operator== because set need to filter the elements with the same value.

However, after reading this link: How do i insert objects into STL set , it seems that overloading operator< is what I need, instead of operator== .

So I code like this:

struct Ele {
    int a, b, c;
    friend bool operator<(const Ele &e1, const Ele &e2);
};
bool operator<(const Ele &e1, const Ele &e2)
{
    if (e1.a < e2.a) {
        return true;
    }
    if (e1.a == e2.a) {
        if (e1.b < e2.b) {
            return true;
        }
        if (e1.b == e2.b) {
            if (e1.c < e2.c) {
                return true;
            }
            return false;
        }
        return false;
    }
    return false;
}

And do a test as below:

set<Ele> myset;
Ele e1;
e1.a = 1;
e1.b = 2;
e1.c = 3;
Ele e2;
e2.a = 1;
e2.b = 2;
e2.c = 3;
myset.insert(e1);
myset.insert(e2);
cout << myset.size() << endl;

Well, the output is 1 , instead of 2 , which means that the insertion for e2 failed as expected because the value of e2 is the same with the value of e1 .

Now I'm confused.

As my understanding, operator< just told the compiler how to understand e1 < e2 , how does compiler know how to understand e1 == e2 ? What if I want to set such a rule: e1 == e2 only if e1.a == e2.b && e1.b == e2.c && e1.c == e2.a ?

Answer 1

== is not sufficient on its own to define an ordering, whereas < is. Furthermore all other relational operators can be cast in terms of operator< , so long as you are allowed to negate the result.

For example, a == b if !(a < b) and !(b < a)

< is a natural choice insofar that thinking of things being in ascending order is natural. > could have been picked, but it wouldn't have been so tractable.

Answer 2

operator< is required because std::map internally is implicitly required by the standard to be a tree-like data structure that requires some kind ordering between elements. Notice that one can generate all the comparing functions using just operator< . Take a look:

a == b <==> !(a < b) && !(b < a)
a > b <==> b < a
a >= b <==> !(a < b)

and so on

Answer 3

You could ensure uniqueness with == (and ! ), but it would be less efficient than using < ( std::set ) or a hash function ( std::unordered_set ).

Consider insert. With only == you would have to compare every element to verify that you don't have an equal element already. std::set 's elements are kept in order, so insert does a binary search, looking at far fewer elements. std::unordered_set 's elements are kept in buckets based on the hash value, so lookup only has to search the bucket, not the whole collection.

As noted in Bathsheba's answer, you can synthesize an equality function from <

Answer 4

The other answers already point out that std::set requires an ordering of the elements which requires operator< to be defined for the type. If you don't care about ordering, and only care about uniqueness, you can use std::unordered_set .

Also, here's a much cleaner way to implement the comparison:

bool operator<(const Ele &e1, const Ele &e2)
{
  return std::tie(e1.a, e1.b, e1.c) < std::tie(e2.a, e2.b, e2.c);
}