Custom ordering for std::priority_queue [duplicate] - c++

Question

This question already has answers here:
declaring a priority_queue in c++ with a custom comparator
(11 answers)
Closed 11 days ago.
I'm trying to make a program that has a std::priority_queue of objects. I want the queue to order the objects based on A::num.
This is the code:
#include <iostream>
#include <queue>
#include <vector>
class A {
public:
int num;
A (int n) {
this->num = n;
}
~A() {
std::cout << "Deleting an A\n";
}
};
struct Compare {
bool operator()(const A* first, const A* second) {
return first->num < second->num;
}
};
int main() {
std::priority_queue AContainer(A*, std::vector<A*>, Compare);
AContainer.push(new A(4));
AContainer.push(new A(8));
AContainer.push(new A(6));
while (AContainer.size() < 0) {
A* del = AContainer.top();
delete del;
del = nullptr;
AContainer.pop();
}
return 0;
}
The compiler returns an error, however I'm not sure why or where it is referring to, or how to fix it:
error: deduced class type 'priority_queue' in function return type
24 | std::priority_queue AContainer(A*, std::vector<A*>, Compare);
| ^~~~~~~~~~
In file included from /usr/include/c++/11/queue:64,
from /tmp/HvPOYonaOt.cpp:3:
/usr/include/c++/11/bits/stl_queue.h:456:11: note: 'template<class _Tp, class _Sequence, class _Compare> class std::priority_queue' declared here
456 | class priority_queue
| ^~~~~~~~~~~~~~
If you could help me out with this that would be great.

Answer 1

A*, std::vector<A*>, Compare are types that you need to supply to the template parameters of std::priority_queue, not values you supply to a constructor.
std::priority_queue<A*, std::vector<A*>, Compare> AContainer;
See it on coliru

Answer 2

Alternative fix using C++17 Class template argument deduction:
std::priority_queue AContainer{Compare{}, std::vector<A*>{}};
Which is closer to your example.
https://godbolt.org/z/547Tq1EnY

Answer 3

In this line you use invalid syntax for instantiating a templated class:
std::priority_queue AContainer(A*, std::vector<A*>, Compare);
The proper syntax is:
std::priority_queue<A*, std::vector<A*>, Compare> AContainer;
Having written this, in modern c++ it is recommended to avoid using raw pointers with manual new/delete whenever possible.
If you can simply store A instances this would be the simplest solution.
If you need pointers (e.g. for using polymorphism, which is not shown in your question), you can use smart pointers, e.g. std::unique_ptr:
#include <iostream>
#include <queue>
#include <vector>
class A {
public:
int num;
A(int n) {
this->num = n;
}
~A() {
std::cout << "Deleting an A\n";
}
};
struct Compare {
bool operator()(std::unique_ptr<A> const & first, std::unique_ptr<A> const & second) {
return first->num < second->num;
}
};
int main() {
std::priority_queue<std::unique_ptr<A>, std::vector<std::unique_ptr<A>>, Compare> AContainer;
AContainer.push(std::make_unique<A>(4));
AContainer.push(std::make_unique<A>(8));
AContainer.push(std::make_unique<A>(6));
while (AContainer.size() > 0) {
AContainer.pop();
}
return 0;
}
Note that you don't have to new or delete any object manually.
A side note: I think you have a typo in your while condition - while (AContainer.size() < 0) should be while (AContainer.size() > 0).