运算符使用自定义类重载C ++ STL映射

Question

I have a doubt regarding using stl map in C++. I know using map with custom classes I need to overload "<" operator to make map work. But how do I define it in a meaningful way. For example I have the following code

#include <iostream>
#include <map>
using namespace std;

struct box{
    int e,s,w;
    box(): e(-1), s(-2), w(-3)
    {}

       bool operator< (const box& lhs) const
       {
           return e < lhs.e;
       }

};

int main() {
    // your code goes here
    map<box, int> hashtable;
    box b;
    hashtable[b] = 1;
    return 0;
}

Here I have overloaded the < operator very trivially. I could have overloaded it as follows too

bool operator< (const box& lhs) const
{
    return w+s+e < lhs.e+lhs.s+lhs.w;
}

And there are other ways too. So my question is, does this, overloading of < operator, affect the search, delete time of accessing the elements in map. I mean does it affect hashing part of the maps. If so, what is the best way to overload < operator.

My only motive here is to store pairs of box and int (see in the main function), so that I can access them in O(log(n)) time.

UPDATE

I figured that having a shitty comparator does not affect the access, delete time of maps but rather have a impact on the keys present in the map. For example if my comparator were the following

bool operator< (const box& lhs) const
{
    return e < lhs.e;
}

and now lets say I two tuples (e,s,w) as (1,2,3) and (1,3,4). I want to insert it into the above map. Now because I have comparator which solely determines on the basis of value of "e", it will reject the second tuple. So finally the map will contains the (1,2,3) not the other tuples.

The best way to write a comparator is using std::tie , as suggested by @edgar in the accepted answer.

bool operator< (const box& lhs) const
{
    return std::tie(e,w,s) < std::tie(lhs.e,lhs.w,lhs.s);
}

In this two tuples are different even if the tuples have different ordering. I had a requirement of that in my question. For example (1,2,3) is different than (2,1,3). Had I use the following comparator

bool operator< (const box& lhs) const
{
    return e+w+s < lhs.e+lhs.w+lhs.s;
}

Again only the first tuple would have made it because both these tuples have same sum, so again not a good comparator.

Answer 1

So my question is, does this, overloading of < operator, affect the search, delete time of accessing the elements in map.

No, it is guaranteed that search, deletion and accessing elements are performed in logarithmic time.

I mean does it affect hashing part of the maps.

std::map is not std::unordered_map , so there is no hashing here.

If so, what is the best way to overload < operator.

I suppose that the standard way now is to use std::tie :

bool operator<(const box& lhs) const
{
    return std::tie(e, s, w) < std::tie(lhs.e, lhs.s, lhs.w);
}

Answer 2

std::map is not a hash map, it's a binary tree.

operator< is invoked every time the tree is accessed, once for each lookup step. So obviously the complexity of it affects performance (overhead aside, the cost of eg a lookup in an std::map is proportional to the cost of operator< ).

std::unordered_map is a hash map. But for that you need to implement std::hash<box> and std::equal_to<box> (hashing and equality functors). operator< isn't used in that case.