C++优先级队列不遵循 FIFO 顺序

您的代码似乎正在工作，因为您首先将紧急项目取出。在基于堆的优先级队列中，没有按插入时间的子排序，因此您将以未定义的顺序获取具有相同优先级的项目，除了它们将排在具有更高优先级的项目之后。您需要添加一个额外的字段，例如放入队列的时间，并将其与比较运算符中的优先级枚举一起使用。

这是另一种可能的stable_priority_queue实现，它保留了priority_queue提供的相同接口：

template <class T>
struct stable_element
{
    stable_element(T&& o, std::size_t c)
        : object_(std::move(o))
        , insertion_order_(c)
    {
    }
    stable_element(const T& o, std::size_t c)
        : object_(o)
        , insertion_order_(c)
    {
    }
    operator T() { return object_; }
    T object_;
    std::size_t insertion_order_;
};
template <class T>
bool operator<(const stable_element<T>& lhs, const stable_element<T>& rhs)
{
    return (lhs.object_ < rhs.object_) || (!(rhs.object_ < lhs.object_) && (rhs.insertion_order_ < lhs.insertion_order_));
}
template <class T,
          class Container = std::vector<stable_element<T>>,
          class Compare = std::less<typename Container::value_type>>
class stable_priority_queue : public std::priority_queue<stable_element<T>, Container, Compare>
{
    using stableT = stable_element<T>;
    using std::priority_queue<stableT, Container, Compare>::priority_queue;
public:
    const T& top() { return this->c.front().object_; }
    void push(const T& value) {
        this->c.push_back(stableT(value, counter_++));
        std::push_heap(this->c.begin(), this->c.end(), this->comp);
    }
    void push(T&& value) {
        this->c.push_back(stableT(std::move(value), counter_++));
        std::push_heap(this->c.begin(), this->c.end(), this->comp);
    }
    template<class ... Args>
    void emplace(Args&&... args) {
        this->c.emplace_back(T(std::forward<Args>(args)...), counter_++);
        std::push_heap(this->c.begin(), this->c.end(), this->comp);
    }
    void pop() {
        std::pop_heap(this->c.begin(), this->c.end(), this->comp);
        this->c.pop_back();
        if (this->empty()) counter_ = 0;
    }
protected:
    std::size_t counter_ = 0;
};

在 std：:p riority_queue 中，有分别对应于基础容器和比较函数对象的受保护成员c和comp。通过这种从 std：:p riority_queue 继承的方法，我们需要修改 top、push、emplace 和 pop 的行为。每个函数的 std：:p riority_queue 文档根据这些函数对c和comp成员的作用提供了这些函数的实现。这对于根据stable_element<T>重写修改后的成员函数非常有帮助。

要将此stable_priority_queue用于 OP 用例，我们只需要提供一个bool operator<(const Lettura& l, const Lettura& r) { return l.priorita < r.priorita; }来根据需要对优先级进行排序：

enum Priority
{
    zero, standard, urgent
};
inline std::ostream& operator <<(std::ostream& os, const Priority& p)
{
    switch (p) {
        case zero:
            os << "zero"; break;
        case standard:
            os << "standard"; break;
        case urgent:
            os << "urgent"; break;
    }
    return os;
}
class Lettura
{
public:
    int      valore;
    char     sensore;
    Priority priorita;
    Lettura()
        : valore(0)
        , sensore('')
        , priorita(zero) {}
    Lettura(const int val, const char s = '', const Priority p = zero)
        : valore(val)
        , sensore(s)
        , priorita(p) {}
    friend std::ostream& operator <<(std::ostream& out, const Lettura& lett)
    {
        return out << "{ valore: " << lett.valore << ", sensore: " << lett.sensore << ", priorita: " << lett.priorita
                   << " }";
    }
};
bool operator<(const Lettura& l, const Lettura& r)
{
    return l.priorita < r.priorita;
}
int main()
{
    stable_priority_queue<Lettura> coda;
    Lettura l1(50, 'a', standard);
    Lettura l2(50, 'b', standard);
    Lettura l3(120, 'c', standard);
    Lettura l5(30, 'e', urgent);
    Lettura l6(35, 'f', standard);
    coda.push(l1);
    coda.push(l2);
    coda.push(l3);
    coda.emplace(100, 'd', standard);
    coda.emplace(l5);
    coda.emplace(l6);
    while (!coda.empty()) {
        std::cout << "top: " << coda.top() << "n";
        coda.pop();
    }
}

输出：

top: { valore: 30, sensore: e, priorita: urgent }
top: { valore: 50, sensore: a, priorita: standard }
top: { valore: 50, sensore: b, priorita: standard }
top: { valore: 120, sensore: c, priorita: standard }
top: { valore: 100, sensore: d, priorita: standard }
top: { valore: 35, sensore: f, priorita: standard }

这是所有这些组合在一起的现场演示

这里是稳定优先级队列的简单实现。

它试图通过在队列为空时将插入计数器归零来抵抗排序耗尽：

#include <iostream>
#include <string>
#include <queue>
#include <algorithm>

enum Priority
{
    zero, standard, urgent
};
inline std::ostream& operator <<(std::ostream& os, const Priority& p)
{
    switch (p) {
        case zero:
            return os << "zero";
        case standard:
            return os << "standard";
        case urgent:
            return os << "urgent";
    }
}
class Lettura
{
public:
    int      valore;
    char     sensore;
    Priority priorita;
    Lettura()
        : valore(0)
        , sensore('')
        , priorita(zero) {}
    Lettura(const int val, const char s = '', const Priority p = zero)
        : valore(val)
        , sensore(s)
        , priorita(p) {}
    friend std::ostream& operator <<(std::ostream& out, const Lettura& lett)
    {
        return out << "{ valore: " << lett.valore << ", sensore: " << lett.sensore << ", priorita: " << lett.priorita
                   << " }";
    }
};

template<class T, class Comp>
struct stable_priority_queue
{
    using counter_type = std::size_t;
    struct Proxy
    {
        Proxy(T&& o, counter_type c)
            : object(std::move(o))
            , insertion_order_(c) {}
        Proxy(const T& o, counter_type c)
            : object(o)
            , insertion_order_(c) {}
        T            object;
        counter_type insertion_order_;
    };
    struct ProxyComp
    {
        bool operator ()(Proxy const& l, Proxy const& r) const
        {
            if (major_order_(l.object, r.object))
                return true;
            if (major_order_(r.object, l.object))
                return false;
            return minor_order_(l.insertion_order_, r.insertion_order_);
        }
        Comp           major_order_;
        std::greater<> minor_order_;
    };

    decltype(auto) push(T item)
    {
        return queue_.emplace(std::move(item), counter_++);
    }
    T const& top() const
    {
        return queue_.top().object;
    }
    void pop()
    {
        queue_.pop();
        if (queue_.empty())
            counter_ = 0;
    }
    std::priority_queue<Proxy, std::vector<Proxy>, ProxyComp> queue_;
    counter_type                                              counter_ = 0;
};
struct lower_priority
{
    bool operator ()(const Lettura& l, const Lettura& r) const
    {
        return l.priorita < r.priorita;
    }
};
int main()
{
    stable_priority_queue<Lettura, lower_priority> coda;
    Lettura l1(50, 'a', standard);
    Lettura l2(50, 'b', standard);
    Lettura l3(120, 'c', standard);
    Lettura l4(100, 'd', standard);
    Lettura l5(30, 'e', urgent);
    Lettura l6(35, 'f', standard);
    coda.push(l1);
    coda.push(l2);
    coda.push(l3);
    coda.push(l4);
    coda.push(l5);
    coda.push(l6);

    std::cout << "top: " << coda.top() << "n";
    coda.pop();
    std::cout << "top: " << coda.top() << "n";
    coda.pop();
    std::cout << "top: " << coda.top() << "n";
    coda.pop();
    std::cout << "top: " << coda.top() << "n";
    coda.pop();
    std::cout << "top: " << coda.top() << "n";
    coda.pop();
    std::cout << "top: " << coda.top() << "n";
    coda.pop();
}

预期成果：

top: { valore: 30, sensore: e, priorita: urgent }
top: { valore: 50, sensore: a, priorita: standard }
top: { valore: 50, sensore: b, priorita: standard }
top: { valore: 120, sensore: c, priorita: standard }
top: { valore: 100, sensore: d, priorita: standard }
top: { valore: 35, sensore: f, priorita: standard }

这似乎是编译器库和C++标准的错误。它们破坏了在priority_queue中选择最大元素的算法。查看我根据堆打开的线程。

为什么 std：：is_heap 使用随机访问迭代器而不是前向迭代器？

我将准备相应的提案。