Question

我正在尝试在类函数中使用stl sort（）。我想对一系列结构进行排序，如下所示：

struct foo{
    double num;
    std::string s;
};

使用这样的比较函数：

bool aGreaterThanb(foo a, foo b){
    if (a.num > b.num){
        if(a.num == b.num){
            if (anotherOutsideComparison(a.s, b.s)){
                return true;
            }
        }
        else
            return true;
    }
    else
        return false;
}

但我不确定如何格式化它以使其编译。我该如何格式化，以便拨打sort(fooarray[0], fooarray[end], aGreaterThanb);？（一个例子很棒）

Answer 1

将比较函数编写为名为仿函数的结构的operator()方法：

struct aGreaterThanb
{
    bool operator() (const foo& a, const foo& b)
    {
        // return true iff a is strictly less than b according to your ordering
    }
};

然后将该仿函数对象的实例传递给std::sort：

std::sort(fooarray.begin(), fooarray.end(), aGreaterThanb());

Answer 2

如果您使用foo这样的数组：

foo fooarray[Foos];
...
sort(fooarray, fooarray + Foos, &aGreaterThanb);

上面的代码会以相反的顺序对数组进行排序，因为sort需要一个小于比较器。

此外，为避免复制大量foo - 对象只是为了进行比较，请将比较器声明为const foo&而不是foo作为参数。

bool aGreaterThanb(const foo& a, const foo& b) {

Answer 3

你应该将迭代器 - 一个指针的通用超集 - 传递给STL sort函数：

std::sort(fooarray, fooarray + end, &aGreaterThanb);

Answer 4

它的工作方式正如您所希望的那样：

#include <algorithm>
int main()
{
    foo     data[10];
    std::sort(&data[0], &data[10], aGreaterThanb);
}

但是你有语法错误。你错过了一个大括号：

        return true;
} // <--- Missing this line
else
    return false;

为了提高效率，你应该通过const引用：

bool aGreaterThanb(foo const& a, foo const& b){

Answer 5

让它成为一名操作员。

struct foo {
    double num;
    std::string s;
};

bool operator>(const foo& a, const foo& b) {
    return (
        (a.num > b.num) ||
        ((a.num == b.num) &&
        anotherOutsideComparison(a.s, b.s))
    );
}

// note: std::sort expects operator<
bool operator<(const foo& a, const foo& b) {
    return b > a;
}

如果您真的想使用operator＆gt;进行排序，请将std::greater<foo>()作为仿函数传递。

std::sort(foos.begin(), foos.end(), std::greater<foo>());

Answer 6

请注意，在最坏的情况下，排序功能最多可达N ^ 2个比较。而且，stable_sort复杂度介于N * logN和N *（LogN ^ 2）

之间

与stl sort（）的比较

6 个答案: