Question

我想构建两个具有不同比较方法的优先级队列（有两个反向优先级方法，名为cmp1和cmp2）我的程序无法通过编译器检查。为什么会发生这样的错误，是否有更好的解决方案？

#include <iostream>
#include <queue>
#include <string>
using namespace std;

struct item
{
    string name;
    string sex;
    string id;
    double score;
    friend istream& operator >> (istream &is,item& data)
    {
        is>>data.name>>data.sex>>data.id>>data.score;
    }
    /*friend bool operator < (item& a,item& b)
    {
        return a.score<b.score;
    }*/
};

struct cmp1{
    operator bool()(item& x,item& y)
    {
        return x.score>y.score;
    }
};
struct cmp2
{
    operator bool()(item& x,item& y)
    {
        return x.score<y.score;
    }
};
int main()
{
    priority_queue<item,vector<item>,cmp1> boys;
    priority_queue<item,vector<item>,cmp2>girls;
    item temp;
    int num;
    cin>>num>>temp;
    for(int i=0;i<num;i++)
    {
        if(temp.sex=="M")
            boys.push(temp);
        else
            girls.push(temp);
    }

    return 0;
}

Answer 1

我会对这个问题大加猜测....你的比较函子是不正确的。您需要重载函数调用运算符，即

，而不是重载operator bool

struct cmp1{
    bool operator()(const item& x, const item& y)
    {
        return x.score>y.score;
    }
};

struct cmp2
{
    bool operator()(const item& x, const item& y)
    {
       return x.score<y.score;
    }
};

（也许这就是你的意图，但只是让语法有点错误？）

Answer 2

实际上，我认为最好的方法是使用std :: less和std :: greater。如果你有重载运算符＆lt;和运算符＆gt;对于你的班级，你可以这样做：

std::priority_queue<item, std::vector<item>, std::greater<item>> boys;
std::priority_queue<item, std::vector<item>, std::less<item>> girls;

这样你就不必编写仿函数了。不要忘记#include <functional>。

另外，不要忘记运算符必须使用const ref参数重载（你也可以按值获取它们，但这通常不是一个好主意），并且作为const方法，如：

bool operator<(const item& i) const {
    return value < i.value;
}
bool operator>(const item& i) const {
    return value > i.value;
}

Answer 3

将您的操作员功能更改为：

struct cmp1{
  bool operator()(item& x,item& y)
  {
    return x.score>y.score;
  }
};
struct cmp2
{
  bool operator()(item& x,item& y)
  {
    return x.score<y.score;
  }
};

Answer 4

您已经在比较类中定义了错误的方法。

请尝试以下代码：

struct cmp1{
    bool operator()(item& x,item& y)
    {
        return x.score>y.score;
    }
};

您已将方法定义为operator bool() ...。

同样很高兴将const添加到参数中，如const item& x表示您不会更改它们的值，以及函数定义末尾的const：

bool operator()(const item& x, const item& y) const {...}

表示您也不会更改成员字段。

Answer 5

我将写下预测的第三个正确版本

struct cmp1
{
    bool operator()( const item &x, const item &y ) const
    {
        return x.score > y.score;
    }
};

struct cmp2
{
    bool operator()( const item &x, const item &y ) const
    {
       return x.score < y.score;
    }
};

c ++中STL的priority_queue

5 个答案: