这是STL中的错误吗？ 为什么在此结构中需要运算符重载？

Question

I came across this code for Equal_range, and being very new to C++, it is not clear to me why we need to overload the operator even though we have created a new compare function .

Moreover, could we have used:

bool compare( const S& s, const S& s2 )
{
    return s.number < s2.number;
}

instead.

#include <algorithm>
#include <vector>
#include <iostream>

struct S
{
    int number;
    char name;

    S ( int number, char name  )
        : number ( number ), name ( name )
    {}

    // only the number is relevant with this comparison
    bool operator< ( const S& s ) const
    {
        return number < s.number;
    }
};

struct Comp
{
    bool operator() ( const S& s, int i )
    {
        return s.number < i;
    }

    bool operator() ( int i, const S& s )
    {
        return i < s.number;
    }
};

int main()
{
    // note: not ordered, only partitioned w.r.t. S defined below
    std::vector<S> vec = { {1,'A'}, {2,'B'}, {2,'C'}, {2,'D'}, {4,'G'}, {3,'F'} };

    auto p = std::equal_range(vec.begin(),vec.end(),2,Comp());

    for ( auto i = p.first; i != p.second; ++i )
        std::cout << i->name << ' ';
}

EDIT: The link to the code is http://en.cppreference.com/w/cpp/algorithm/equal_range

Answer 1

I think this is a bug in your STL implementation. The C++ standard explicitly states it will not call operator< in this case:

The elements are compared using operator< for the first version, and comp for the second . Two elements, a and b are considered equivalent if (!(a<b) && !(b<a)) or if (!comp(a,b) && !comp(b,a)).

"First version" refers to the version where no comparison class is provided. "second" refers to the version you used.

I tried this out on VS2013 but it doesn't even compile. The error is:

error C2664: 'bool Comp::operator ()(const S &,int)' : cannot convert argument 1 from 'S' to 'int'

Unfortunately, the error is deep down inside Microsoft's obfuscated STL implementation. Why would it call operator()(const S&, int) instead of operator()(int, const S&) ?

So I think Visual Studio's STL implementation is wrong. And if your compiler requires it, I think its STL is also wrong. I wonder if they just never tested this where the third argument is not the same type as what is returned by the iterator.

I would love to hear other people's thoughts on this.

Answer 2

In your example code, your various methods of comparing all do different things; the operator< overload allows you to compare an S with another S , where as the Comp struct allows you to compare an S with an int and vise-versa.

If you read the documentation for equal_range

The elements are compared using operator< for the first version, and comp for the second

You see that you need to be able to do both a[n] < a[i] and comp(a[n], val) , the first to compare items in the list to other items in the list, and the second to be able to compare items in the list to the val parameter of the equal_range call. Hence why you need both an operator overload and a comparison method.