在c ++中排序类的向量

Question

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

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]'

Answer 1

您的比较器需要指针，但该向量包含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());

Answer 2

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

选项1：内部运算符＆lt;（）

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

使用默认的std :: less＆lt;＆gt;进行调用模板。

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：外部运算符＆lt;（）

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

这与（1）一样，使用默认的std :: less＆lt;＆gt;比较器，但要求外部运算符也是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

Answer 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
}

Answer 4

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

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

Answer 5

通常，当你有一个你希望STL为你排序的对象时，要么使用sort方法，要么把它放在std :: set中，你需要一个运算符＆lt;方法

因此，最好让它成为班上的一员。该方法的签名应该是这样的： bool operator＆lt;（const Parola＆amp; left，const Parola＆amp; right）

如何实施它取决于你的班级本身。