Why C++ STL containers use "less than" operator< and not "equal equal" operator== as comparator?

Question

While implementing a comparator operator inside a custom class for std::map, I came across this question and couldn't see anywhere being asked.

Apart from the above question, also interested to know in brief, how operator< would work for std::map.

Origin of the question:

struct Address {
  long m_IPv4Address;
  bool isTCP;
  bool operator< (const Address&) const;  // trouble
};

if you know how to compare with `<` then everything else can be generated. check [here](http://stackoverflow.com/q/23388739/4224575) — Lorah Attkins, Nov 26 '14 at 15:48
@jrok: Not necessarily. They're equivalent with respect to the ordering, but only equal if the definition of `operator==` agrees. — Mike Seymour, Nov 26 '14 at 15:49
@jrok: They use equivalence, not equality. The two concepts don't necessarily mean the same thing. — Mike Seymour, Nov 26 '14 at 15:51
@RSahu I disagree, that [linked post](http://stackoverflow.com/questions/22308437/why-use-stdless-as-the-default-functor-to-compare-keys-in-stdmap-and-stdse) did not have answers that answer the OP's question — Yakk - Adam Nevraumont, Nov 26 '14 at 15:59

score 9 · Accepted Answer · answered Nov 26 '14 at 15:57

std::map<K,D> needs to be able to sort. By default is uses std::less<K>, which for non-pointers uses <¹.

Using the rule that you demand the least you can from your users, it synthesizes "equivalence" from < when it needs it (!(a<b) && !(b<a) means a and b are equivalent, ie, neither is less than the other).

This makes it easier to write classes to use as key components for a map, which seems like a good idea.

There are std containers that use == such as std::unordered_map, which uses std::hash and ==. Again, they are designed so that they require the least from their users -- you don't need full ordering for unordered_ containers, just equivalence and a good hash.

As it happens, it is really easy to write a < if you have access to <tuple>.

struct Address {
  long m_IPv4Address;
  bool isTCP;
  bool operator< (const Address& o) const {
    return
      std::tie( m_IPv4Address, isTCP )
      < std::tie( o.m_IPv4Address, o.isTCP );
  }
};

which uses std::tie defined in <tuple> to generate a proper < for you. std::tie takes a bunch of data, and generates a tuple of references, which has a good < already defined.

¹ For pointers, it uses some comparison that is compatible with < where < behaviour is specified, and behaves well when < does not. This only really matters on segmented memory model and other obscure architectures.

The std::tie trick is great, this is the kind of elegant solution I was looking for. — Stefan Monov, Jan 30 '17 at 16:40

quantdev · Answer 2 · 2014-11-26T15:51:48.697

6

Because std::map is a sorted associative container, it's keys need ordering.

An == operator would not allow to order multiple keys

You might be looking for std::unordered_map , which work has a hashtable. You can specify your own hash and equality operator functions :

explicit unordered_map( size_type bucket_count,
                    const Hash& hash = Hash(),
                    const KeyEqual& equal = KeyEqual(),
                    const Allocator& alloc = Allocator() );

edited Nov 26 '14 at 15:51

answered Nov 26 '14 at 15:46

quantdev

23,517
5
55
88

Is same thing true for `unordered_map`? – iammilind Nov 26 '14 at 15:49
@iammilind: No, that uses a hash function and an equality comparison. – Mike Seymour Nov 26 '14 at 15:49
@iammilind : no, an unordered_map is like a hashtable, mybe it is what you are looking for ? updated. – quantdev Nov 26 '14 at 15:52

score 2 · Answer 3 · answered Nov 26 '14 at 15:48

With < you can order elements. If a < b then a should be placed before b in the collection.

You can also determine if two items are equivalent: if !(a < b) && !(b < a) (if neither object is smaller than the other), then they're equivalent.

Those two capabilities are all std::map requires. So it just expects its element type to provide an operator <.

With == you could determine equality, but you wouldn't be able to order elements. So it wouldn't satisfy the requirements of std::map.

Why C++ STL containers use "less than" operator< and not "equal equal" operator== as comparator?

3 Answers3