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:我将只展示50多个错误中的前三行：

/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

为操作员提供一些可供选择的选项：(注意:不是详尽的)

选项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

Answer 2

比较器接受指针，但向量保存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 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());

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

bool operator< (Parola const& p0, Parola const& p1) {
    // again, a strict weak order on Parola objects
}