访问类的私有成员的自定义优先级队列比较器

Custom priority queue comparator that accesses private members of a class

本文关键字：优先级 队列 自定义 比较器 访问 成员      更新时间：2023-10-16

如果你看下面的代码，我正在尝试创建一个priority_queue，我把它命名为DijkstraPriorityQueue，它有一个自定义比较器，它也使用私有向量distTo。

你可以看到我有一些点.......因为我尝试的所有东西都失败了。

在

这种特定情况下，使这项工作按预期工作的最干净的解决方案（或可能的解决方案）是什么？

Dijkstra.h

class Dijkstra
{
public:
    Dijkstra(Graph G, int s);                          // Create
    ~Dijkstra();                                       // Destroy
private:
    bool compare(int u, int v)
    {
        return distTo[u] < distTo[v];
    }
    typedef priority_queue<int, vector<int>, .........> DijkstraPriorityQueue;

    vector<float>         distTo; // distTo[u] is the distance of the shortest s->u path 
    DijkstraPriorityQueue PQ;     // Min-Priority Queue, implemented for Dijkstra
};

迪克斯特拉.cpp

Dijkstra::Dijkstra(Graph G, int s)
{
     PQ = DijkstraPriorityQueue(...........);
}

选项 #1

#include <functional>
#include <queue>
#include <vector>
class Dijkstra
{
public:
    Dijkstra()
        : PQ([this](int u, int v){ return distTo[u] < distTo[v]; })
    {
    }
private:    
    using DijkstraPriorityQueue
       = std::priority_queue<int, std::vector<int>, std::function<bool(int,int)>>;
    std::vector<float> distTo;
    DijkstraPriorityQueue PQ;
};

选项 #2

#include <functional>
#include <queue>
#include <vector>
class Dijkstra
{
public:
    Dijkstra()
        : PQ(std::bind(&Dijkstra::compare, this, std::placeholders::_1, std::placeholders::_2))
//      or
//      : PQ([this](int u, int v){ return compare(u, v); })
    {
    } 
private:    
    bool compare(int u, int v) const
    {
        return distTo[u] < distTo[v];
    }
    using DijkstraPriorityQueue
       = std::priority_queue<int, std::vector<int>, std::function<bool(int,int)>>;
    std::vector<float> distTo;
    DijkstraPriorityQueue PQ;
};

选项 #3

（作为记录，如果您坚持使用C++03）：

#include <queue>
#include <vector>
class Dijkstra
{
public:
    Dijkstra()
        : PQ(compare(this))
    {
    }
private:
    struct compare
    {
        explicit compare(Dijkstra* d) : d(d) {}
        bool operator()(int u, int v) const
        {
            return d->distTo[u] < d->distTo[v];
        }
        const Dijkstra* d;
    };
    typedef std::priority_queue<int, std::vector<int>, compare> DijkstraPriorityQueue;
    std::vector<float> distTo;
    DijkstraPriorityQueue PQ;
};
相关文章：