2

我在使用排序功能时遇到了一些问题......这是我的代码： 

class Parola {
public:
    string s;
    int repetition;
    bool operator()(const Parola *x, const Parola *y) {
        return x->repetition > y->repetition;
    }
};


int main(int argc, char** argv) {
    ...
    vector<Parola> p;
    ...
    some insertions here
    ...
    sort(p.begin(), p.end(), Parola());
    ...
    return 0;
}

为什么我不能在没有错误的情况下编译它？非常感谢！

PS：我只会向您展示超过五十个错误的前三行：

/usr/include/c++/4.2.1/bits/stl_algo.h: In function 'const _Tp& std::__median(const _Tp&, const _Tp&, const _Tp&, _Compare) [with _Tp = Parola, _Compare = Parola]':
/usr/include/c++/4.2.1/bits/stl_algo.h:2795:   instantiated from 'void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Parola*, std::vector<Parola, std::allocator<Parola> > >, _Size = long int, _Compare = Parola]'
/usr/include/c++/4.2.1/bits/stl_algo.h:2866:   instantiated from 'void std::sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<Parola*, std::vector<Parola, std::allocator<Parola> > >, _Compare = Parola]'
4

5 回答 5

6

您的比较器采用指针，但向量包含Parola实例。你需要改变它。但最简单的方法是实现小于比较运算符。

class Parola {
public:
    string s;
    int repetition;
};

bool operator<(const Parola& x, const Parola& y) {
    return x.repetition < y.repetition;
}

然后你可以sort在没有第三个参数的情况下调用：

sort(p.begin(), p.end());
于 2012-10-08T18:13:31.270 回答
5

为 OP 提供一些可供选择的选项：（注意：并非详尽无遗）

选项 1：内部运算符 <()

class Parola {
public:
    string s;
    int repetition;
    bool operator<(const Parola& x) const  
    {
        return repetition < x.repetition;
    }
}

使用默认的 std::less<> 模板调用。

sort(p.begin(), p.end());

选项 2：内部功能运算符（）（）：

class Parola {
public:
    string s;
    int repetition;
    bool operator()(const Parola& x, const Parola& y) const  
    {
        return x.repetition < y.repetition;
    }
}

正如 dasblinken 指出的那样，用可选的比较对象调用，很奇怪，但有效：

std::sort(p.begin(), p.end(), Parola());

选项 3：外部运算符 <()

bool operator <(const Parola& x, const Parola& y)
{
    x.repetition < y.repetition;
}

这与 (1) 一样，使用默认的 std::less<> 比较器，但要求外部运算符也是 Parola 类的朋友，以便在声明为私有数据成员时访问私有数据成员。其用法同（1）。

选项 4：外部函子

class CompareParola
{
public:
   bool operator ()(const Parola& x, const Parola& y) const
   {
      return x.repetition < right.repetition;
   }
};

并由以下人员使用：

std::sort(p.begin(), p.end(), CompareParola());

与 (3) 一样，如果访问的成员是私有的，CompareParola 类必须是 Parola 的好友：

选项 5：外部函数

bool ParolaLess(const Parola& x, const Parola& y)
{
    return x.repetition < y.repetition;
}

与外部运算符或外部函数类类似，这也需要与对象类成为朋友才能访问私有成员。像这样调用：

std::sort(p.begin(), p.end(), ParolaLess);

选项 6：静态类函数

class Parola {
public:
    string s;
    int repetition;

    static bool Less(const Parola& x, const Parola& y)  
    {
        return x.repetition < y.repetition;
    }
};

这通常未被充分利用，并且具有访问所有对象成员变量的非常好的属性，包括私有变量（显然，它是用类定义的）。您可以通过以下方式使用它：

std::sort(p.begin(), p.end(), Parola::Less)

请注意，这与 (1) 和 (2) 一样，将所有内容都保留在类中。

在所有这些中，我更喜欢（1）它的简单性，（4）它的独立性，但每个人都有自己的品味。有时 (5) 或 (6) 真的会派上用场（我是 (6) 的个人粉丝）。

如果您能想到更多并让代表对其进行编辑，请根据需要进行更新。请尽量让它们至少有点用=P

于 2012-10-08T18:40:59.007 回答
3

您的直接问题是您的比较运算符没有传递Parola const*对象而是Parola const&对象：迭代器被取消引用以获取实际比较的值。

下一个问题是您可能不应该尝试将您的比较对象捆绑到您的实际对象中：比较对象的行为并不像一个Parola对象。您想要一个单独的比较器，然后将其用于std::sort()：

sturct ParolaCompare {
    bool operator()(Parola const& p0, Parola const& p1) const {
        // return something defining a strict weak order on Parola objects
    }
};
// ...
std::sort(v.begin(), v.end(), ParolaCompare());

或者，您可以定义一个适合operator<()您的Parola对象：

bool operator< (Parola const& p0, Parola const& p1) {
    // again, a strict weak order on Parola objects
}
于 2012-10-08T18:17:08.110 回答
2

使运算符采用 const 引用而不是指针。IE 

bool operator()(const Parola &x, const Parola &y) { 
    return x.repetition > y.repetition; 
}
于 2012-10-08T18:14:53.347 回答
-1

通常，当您有一个希望 STL 为您排序的对象时，无论是使用 sort 方法，还是将其放入 std::set 中，您都需要一个 operator< 方法。

因此，最好使其成为类的成员。该方法的签名应该类似于： bool operator<(const Parola& left, const Parola& right)

你如何实现它取决于你的类本身。

于 2012-10-08T18:16:14.483 回答