Question

我正在开发这个程序来运行带有堆实现的Dijkstra算法，我希望它能够像它一样多功能，所以我使用函数指针以避免代码重复。这是它弹出的错误。我正在使用stl make_heap

"Type must use '.*' or '->*' to call pointer-to-member function in '__comp (...)', e.g. '(... ->* __comp) (...)' "heap.h     C/C++ Problem

这是Dijkstra的算法：

void Graph::dijkstraAlg(Vertex* ini, Vertex* fin, void(Graph::*weight_filler)(void), bool(Graph::*pq_order)(const Vertex* &, const Vertex* &)){

for(unsigned int i = 0; i < vertexs.size(); i++) {
    vertexs[i]->path = NULL;
    vertexs[i]->holder = MAX_INT_VALUE;
    vertexs[i]->processing=false;
}

(this->*weight_filler)();

Vertex* v=ini;
v->holder = 0;
v->processing = true;

vector<Vertex*> pq;
pq.push_back(v);
make_heap(pq.begin(),pq.end(),pq_order);

while(!pq.empty()){

    v=pq.front();
    pop_heap(pq.begin(),pq.end());
    pq.pop_back();

    for(unsigned int u=0; u < v->adj.size(); u++){

        Vertex* w = v->adj[u]->dest;

        if((v->holder+v->adj[u]->weight) < w->holder){

            w->holder=v->holder + v->adj[u]->weight;
            w->path=v;

            if(!w->processing){

                w->processing=true;
                pq.push_back(w);
            }
        }

        make_heap(pq.begin(),pq.end(),pq_order);
    }
}

return;}

错误在make_heap中，我无法弄明白，任何帮助都表示赞赏。

这是我传递给make_heap的函数：

bool Graph::regular_PqOrder(const Vertex* &v, const Vertex* &u){
return v->holder > u->holder;}

这就是我称之为算法的方式：

dijkstraAlg(i,f,&Graph::price_WeightFiller,&Graph::regular_PqOrder);

如果您需要更多信息，请告诉我并进行编辑。谢谢朋友

Answer 1

你传递了错误的类型。 std::make_heap将functor作为第三个元素，它应该满足Compare的要求，这是你需要的：

bool operator()(const Type1&, const Type2&) const;

您传递的是pq_order类型：

bool(Graph::*)(const Vertex* &, const Vertex* &)

这是指向成员的指针，如果没有Graph类型的对象，它就无法调用。因此，关于＆＃34;类型的错误必须使用＆＃39;。＆＃39;或者＆＃39; - ＆gt; ＆＃39;调用指向成员的指针＆＃34;。最简单的方法是简单地提供该对象，在您的情况下为this：

using namespace std::placeholders;
std::make_heap(pq.begin(), pq.end(), 
    std::bind(pq_order, this, _1, _2));

或者，由于regular_PqOrder实际上并不依赖于Graph其他方法的任何成员，因此您也可以将其设为静态：

class Graph { 
public:
    static bool regular_PqOrder(const Vertex* &v, const Vertex* &u) 
    {
        return v->holder > u->holder;
    }
};

现在传递Graph::regular_PqOrder作为函数指针，而不是指向方法的指针。

Answer 2

我已将您的问题简化为：

#include <algorithm>
#include <vector>

using namespace std;

class Vertex
{};

class Graph
{
public:
    void dijkstraAlg(Vertex* ini, Vertex* fin, void(Graph::*weight_filler)(void), 
                                               bool(Graph::*pq_order)(const Vertex*, const Vertex*))
    {
        (this->*weight_filler)();

        struct Comparator
        {
        private:

            Graph* m_g;
            bool(Graph::*m_fn)(const Vertex*, const Vertex*);
        public:
            Comparator(Graph* g, bool(Graph::*fn)(const Vertex*, const Vertex*)) : m_g(g), m_fn(fn)
            {}

            bool operator()(const Vertex* one, const Vertex* two) const
            {
                return (m_g->*m_fn)(one, two);
            }
        };

        Comparator comparator(this, pq_order);

        vector<Vertex*> pq;
        std::make_heap(pq.begin(), pq.end(), comparator);
    }

    void weight_filler1()
    {        
    }
    bool pq_order1(const Vertex*, const Vertex*)
    {
        return false;
    }

};

int main()
{
    Graph g;
    g.dijkstraAlg(nullptr, nullptr, &Graph::weight_filler1, &Graph::pq_order1);

    return 0;
}

问题是：std::make_heap需要一个函数指针 - 在你的情况下，你传递一个指向成员函数的指针，因此问题。

您可以更改dijkstraAlg的声明，只接受一个静态函数指针pq_order或将pq_order包装在一个结构中，使其成为一个可调用的实体，就像我一样完成。

注意：您必须修复pq_order中make_heap指针的引用才能编译

在stl make_heap c ++中将function_pointer作为比较器传递

2 个答案: