如何使优先级队列使用自定义类中的变量（升序/降序） 我在C++中使用 PrimyItQueIs/COD>有问题，我有一个优先级队列的向量，优先级队列包含几个人> /Cord>对象。现在我想让priority\u队列根据年龄对Person对象进行优先级排序。所以我有这样的想法： class Person { public: string name; int height; int age; }; std::vector<std::priority_queue<Person*>> Persons; 班级人员 { 公众： 字符串名； 内部高度； 智力年龄； }; 性病媒人；

我如何确保每当一个人被添加到一个优先级队列时，他们都会根据年龄进行优先级排序？我将如何按升序/降序进行操作？

std:：priority\u queue

为您提供了一个接口。它需要三个模板参数：

template<
    class T,
    class Container = std::vector<T>,
    class Compare = std::less<typename Container::value_type>
> class priority_queue;

模板<
T类，
类容器=std:：vector，
类比较=std:：less
>类优先级队列；

第三个是处理元素比较需要更改的内容

// make a functor to do the comparisons
struct comparator
{
    bool operator()(Person* lhs, Person* rhs) const {
        // sort by age
        return lhs->age < rhs->age; // switch the sign for reverse order
    }
};

// have a type alias for convenience (typedef is fine too)
using pqueue = std::priority_queue<Person*, std::vector<Person*>, comparator>;

int main() 
{
    std::vector<pqueue> persons; 
}

//制作一个函子来进行比较
结构比较器
{
布尔运算符（）（Person*lhs，Person*rhs）常量{
//按年龄分类
返回lhs->ageage；//切换符号以获得相反顺序
}
};
//为方便起见，请使用类型别名（typedef也可以）
使用pqueue=std:：priority_队列；
int main（）
{
性病媒人；
}

std:：priority\u queue

为您提供了一个接口。它需要三个模板参数：

template<
    class T,
    class Container = std::vector<T>,
    class Compare = std::less<typename Container::value_type>
> class priority_queue;

模板<
T类，
类容器=std:：vector，
类比较=std:：less
>类优先级队列；

第三个是处理元素比较需要更改的内容

// make a functor to do the comparisons
struct comparator
{
    bool operator()(Person* lhs, Person* rhs) const {
        // sort by age
        return lhs->age < rhs->age; // switch the sign for reverse order
    }
};

// have a type alias for convenience (typedef is fine too)
using pqueue = std::priority_queue<Person*, std::vector<Person*>, comparator>;

int main() 
{
    std::vector<pqueue> persons; 
}

//制作一个函子来进行比较
结构比较器
{
布尔运算符（）（Person*lhs，Person*rhs）常量{
//按年龄分类
返回lhs->ageage；//切换符号以获得相反顺序
}
};
//为方便起见，请使用类型别名（typedef也可以）
使用pqueue=std:：priority_队列；
int main（）
{
性病媒人；
}

您可以这样实现：

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



class Person
{
public:
    string name;
    int height;
    int age;

};

struct OrderByAge
{
    bool operator() (Person const &a, Person const &b) { return a.age > b.age; }
};


int main() 
{
    vector<priority_queue<Person, std::vector<Person>,OrderByAge> > personPQVec{ 1 };

    Person p1{ "nitendra",5,39 };
    Person p2{ "bhosle",6,34 };
    Person p3{ "nit",4,33 };


    personPQVec[0].push(p1);
    personPQVec[0].push(p2);
    personPQVec[0].push(p3);


    while (!personPQVec[0].empty()) {

        cout << "Name: " << (personPQVec[0]).top().name << ", age: " << (personPQVec[0]).top().age << endl;
        (personPQVec[0]).pop();
    }
    system("pause");
    return 0;
}

#包括
#包括
#包括
#包括
使用名称空间std；
班主任
{
公众：
字符串名；
内部高度；
智力年龄；
};
结构OrderByAge
{
bool操作符（）（Person const&a，Person const&b）{返回a.age>b.age；}
};
int main（）
{
向量personPQVec{1}；
p1人{“nitendra”，5,39}；
p2人{“bhosle”，6,34}；
人p3{“nit”，4,33}；
personPQVec[0]。推送（p1）；
personPQVec[0]。推送（p2）；
personPQVec[0]。推送（p3）；
而（！personPQVec[0].empty（））{
cout您可以这样实现：

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



class Person
{
public:
    string name;
    int height;
    int age;

};

struct OrderByAge
{
    bool operator() (Person const &a, Person const &b) { return a.age > b.age; }
};


int main() 
{
    vector<priority_queue<Person, std::vector<Person>,OrderByAge> > personPQVec{ 1 };

    Person p1{ "nitendra",5,39 };
    Person p2{ "bhosle",6,34 };
    Person p3{ "nit",4,33 };


    personPQVec[0].push(p1);
    personPQVec[0].push(p2);
    personPQVec[0].push(p3);


    while (!personPQVec[0].empty()) {

        cout << "Name: " << (personPQVec[0]).top().name << ", age: " << (personPQVec[0]).top().age << endl;
        (personPQVec[0]).pop();
    }
    system("pause");
    return 0;
}

#包括
#包括
#包括
#包括
使用名称空间std；
班主任
{
公众：
字符串名；
内部高度；
智力年龄；
};
结构OrderByAge
{
bool操作符（）（Person const&a，Person const&b）{返回a.age>b.age；}
};
int main（）
{
向量personPQVec{1}；
p1人{“nitendra”，5,39}；
p2人{“bhosle”，6,34}；
人p3{“nit”，4,33}；
personPQVec[0]。推送（p1）；
personPQVec[0]。推送（p2）；
personPQVec[0]。推送（p3）；
而（！personPQVec[0].empty（））{
cout您可以传递一个谓词作为第三个参数来检测排序顺序，为您的
Person*

struct AscendingPersonPredicate
{
    bool operator() ( Person* p1, Person* p2) const
    {
        return p1->age < p2->age;
    }
};

struct DescendingPersonPredicate
{
    bool operator() ( Person* p1, Person* p2) const
    {
        return p1->age > p2->age;
    }
};

结构AscendingPersonPredicate
{
布尔运算符（）（Person*p1，Person*p2）常量
{
返回p1->ageage；
}
};
结构下降PersonPredicate
{
布尔运算符（）（Person*p1，Person*p2）常量
{
返回p1->age>p2->age；
}
};

然后将向量声明为：

std::priority_queue<Person*, vector<Person*>, AscendingPersonPredicate> Persons;

std:：优先队列人员；

或

std:：优先队列人员；
您可以传递一个谓词作为第三个参数来检测排序顺序，并为您的
人员声明两个谓词*

struct AscendingPersonPredicate
{
    bool operator() ( Person* p1, Person* p2) const
    {
        return p1->age < p2->age;
    }
};

struct DescendingPersonPredicate
{
    bool operator() ( Person* p1, Person* p2) const
    {
        return p1->age > p2->age;
    }
};

结构AscendingPersonPredicate
{
布尔运算符（）（Person*p1，Person*p2）常量
{
返回p1->ageage；
}
};
结构下降PersonPredicate
{
布尔运算符（）（Person*p1，Person*p2）常量
{
返回p1->age>p2->age；
}
};

然后将向量声明为：

std::priority_queue<Person*, vector<Person*>, AscendingPersonPredicate> Persons;

std:：优先队列人员；

或

std:：优先队列人员；
实际上，您不需要额外的向量来包装优先级队列，因为优先级队列本身有两个额外的默认参数：
（第一个是类型，在您的例子中是Person*），第二个是容器类型，第三个是比较谓词。
下面您可以看到使用lambda函数作为优先级队列的比较谓词

#include <vector>
#include <string>
#include <queue>
#include <iostream>

using namespace std;

class Person
{
public:
    string name;
    int height;
    int age;

    Person(string n, int h, int a): name(n), height(h), age(a) {}
};


ostream& operator<<(ostream &cout, const Person* p) {
    return cout << p->name << " height=" << p->height << " age=" << p->age << " ";
}

int main()
{
    auto cmp = [](const Person* pl, const Person* pr) {
        return (pl->age < pr->age);
    };

    priority_queue<Person*, vector<Person*>, decltype(cmp)> persons(cmp);

    persons.push(new Person("a", 100, 10));
    persons.push(new Person("b", 120, 20));
    persons.push(new Person("c", 110, 15));

    while (!persons.empty()) {
        cout << persons.top() << endl;
        persons.pop();
    }

    return 0;
}

#包括
#包括
#包括
#包括
使用名称空间std；
班主任
{
公众：
字符串名；
内部高度；
智力年龄；
Person（字符串n，inth，inta）：姓名（n），身高（h），年龄（a）{}
};
ostream&operator实际上，您不需要额外的向量来包装优先级队列，因为优先级队列本身有两个额外的默认参数：
（第一个是类型，在您的例子中是Person*），第二个是容器类型，第三个是比较谓词。
下面您可以看到使用lambda函数作为优先级队列的比较谓词

#include <vector>
#include <string>
#include <queue>
#include <iostream>

using namespace std;

class Person
{
public:
    string name;
    int height;
    int age;

    Person(string n, int h, int a): name(n), height(h), age(a) {}
};


ostream& operator<<(ostream &cout, const Person* p) {
    return cout << p->name << " height=" << p->height << " age=" << p->age << " ";
}

int main()
{
    auto cmp = [](const Person* pl, const Person* pr) {
        return (pl->age < pr->age);
    };

    priority_queue<Person*, vector<Person*>, decltype(cmp)> persons(cmp);

    persons.push(new Person("a", 100, 10));
    persons.push(new Person("b", 120, 20));
    persons.push(new Person("c", 110, 15));

    while (!persons.empty()) {
        cout << persons.top() << endl;
        persons.pop();
    }

    return 0;
}

#包括
#包括
#包括
#包括
使用名称空间std；
班主任
{
公众：
字符串名；
内部高度；
智力年龄；
Person（字符串n，inth，inta）：姓名（n），身高（h），年龄（a）{}
};
ostream&Operator您是否尝试过咨询合适？您是否见过模板参数
比较
？您是否尝试过咨询合适？您是否见过模板参数
比较
？