排序比较功能怪异行为

Question

The function below is my compare function. While comparing directly two characters successfully assorts the array, using the std::string compare function doesn't.

int compare (student a, student b) {
  return a.name.compare(b.name);
  return a.name[0] < b.name[0];
}

The call

sort(data.begin(), data.end(), compare);

Where data is defined as vector <student> data;

Have you got any ideas why is it that std::compare doesn't sort it?

PS: std::compare results in inverting the positions, eg alan, richard, byron, sarah -> sarah, byron, richard, alan.

Answer 1

std::string::compare returns an int which you are meant to compare to 0 to give an actual sort order. For example, to check if a.name is less than b.name (according to the ordering given by compare ) you would write:

return a.name.compare(b.name) < 0;

The way that you have currently written it will return true for any unequal strings, which is not a valid strict weak ordering , as required for std::sort .

There is no good reason to use compare here at all, as std::string has an operator< that gives an equivalent ordering of the two strings:

return a.name < b.name;

Answer 2

Have a read through the std::sort reference at cppreference.com ; it clearly explains that the comparison function should return a bool which indicates the first argument is less than the second.

In this case, you would call it like this:

std::sort(data.begin(), data.end(), [](student const& a, student const& b) {
    return a.name < b.name;
})

So, what's happening in your code? If the name s are equal, compare returns 0, which is cast to false . Otherwise, you will get a non-zero integer, which will be cast to true . Since the sorting algorithm in std::sort isn't specified absolutely, we can't say why you are getting a certain order precisely, but essentially, std::sort is std::swap ing objects (pseudo) randomly.

So, should you define a compare function? IMHO, no. It is quite easily to define for some basic types, but as far as I can tell, it doesn't really appear in any algorithms. It is a C-ism, and unfortunately, C++ kept it. If appropriate, define a strict weak ordering using operator< instead, or just define comparators when needed.

Answer 3

排序预计其比较的行为类似于运营商<，而的std :: string ::所描述的行为比较这里 。

Answer 4

You're returning an int which std::sort sees as either "same" or "not same". You should be returning this:

return a.name.compare(b.name) < 0;

And change the return type to bool

However, have you considered this instead:

class student
{
public:
   ... members ...

   bool operator <(const student& s) const
   {
       return name < s.name;
   }

private:
   std::string name;
};

And get rid of the custom comparator you're trying to fabricate entirely . With this you can then sort a collection of students using just std::sort(students.begin(), students.end()) , since the default comparator, std::less<YourType> , will invoke your operator when doing comparisons while sorting.