Implementing a priority queue that can be iterated over in C++
I need to implement a priority queue for a project, bu开发者_如何转开发t the STL's priority_queue
is not indicated since we need to iterate over all elements and remove them randomly.
We are thinking about using the STL's set
for this, wrapping it in a class to make it an ADT.
Is there a smarter solution for this?
How can we make it so some of set
's public member functions can be used publicly? We're interested in iterators, etc.
Apparently deriving the STL is unwise because of the lack of virtual destructors :/
New code:
#ifndef PRIORITYQUEUE_H_
#define PRIORITYQUEUE_H_
#include <set>
template<typename T, template<typename X> class impl_type = std::set>
class PriorityQueue {
typedef impl_type<T> set_type;
typedef typename set_type::iterator iterator;
public:
void push(const T& x) {
insert(x);
}
void pop() {
erase(begin());
}
const T& top() const {
return *begin();
}
};
#endif /* PRIORITYQUEUE_H_ */
So, we currently have this. The compiler doesn't complain about insert, but it does complain about erase(begin())
and return *begin()
:
there are no arguments to 'begin' that depend on a template parameter, so a declaration of 'begin' must be available
Why is this?
Do you really need a priority queue ?
You need iterate over all items and remove randomly -> linked list
If you need to keep the list sorted, sort it at the beginning and then, when inserting new item, use insertion sort (insert new item on right place).
You should be able to implement your own priority queue using std::vector
, std::make_heap
, std::push_heap
, and std::pop_heap
. Isn't this how std::priority_queue
is implemented? You'll just need to call std::make_heap
again to fix the data structure when you remove a random element.
Do you need to iterate over the elements in order? There's a std::sort_heap
algorithm to order the underlying std::vector
.
STL's set should be usable to make what you want, although I must note that the list of requirements looks a little strange. You could just define a new type.
template<typename T, template<typename X> class impl_type = std::set> class prio_queue {
typedef impl_type<T> set_type;
typedef typename set_type::iterator iterator;
// etc
public:
// Forward the set's members
T& top() {
return *begin();
}
// etc
};
I would follow the example set by some of the other container adapters in the standard library use composition and make the type of the underlying container a template parameter. Though since it is a school project that might be too much flexibility. You might start by using composition with one of the existing Containers and build from there if necessary.
精彩评论