如何使std :: pop_heap接受适当的函数指针作为比较？

Question

I have a Node class with the functions

static bool HasGreaterF(const Node& a, const Node& b);
static bool HasGreaterF(const std::shared_ptr<Node>& a, const std::shared_ptr<Node>& b);

Then I make a vector as heap and would like to use the second function as Compare. This doesn't work, because the function pointer can't get matched to one function. If I delete the first function it works. How to make it work with both functions?

std::vector<std::shared_ptr<Node>> openlist_min_f;
std::pop_heap(openlist_min_f.begin(), openlist_min_f.end(), &Node::HasGreaterF);

Answer 1

Use static_cast to specify it:

std::pop_heap(openlist_min_f.begin(), openlist_min_f.end(), 
              static_cast<bool (*)(const std::shared_ptr<Node>&, const std::shared_ptr<Node>&)>
              (&Node::HasGreaterF));

Or use a lambda wrapper as @David suggested, since the functions should not be ambiguous in this case.

std::pop_heap(openlist_min_f.begin(), openlist_min_f.end(), 
              [](const auto& l, const auto& r){ return Node::HasGreaterF(l, r); });

Answer 2

The reason you can't use it as-is is that pop_heap has to deduce the type of the comparator you pass in, and an overloaded function doesn't have one type. There's contexts in which you can use the name of an overloaded function outside of simply calling them, but passing as an argument to a function template isn't one them. In this case, you have to explicitly state which HasGreaterF you mean.

You can either use a static_cast (as mentioned) or just wrap it in a lambda:

std::pop_heap(openlist_min_f.begin(), openlist_min_f.end(),
    [](const auto& lhs, const auto& rhs) { return Node::HasGreaterF(lhs, rhs); });

The lambda has the advantage in that it has a greater likelihood of being inlined in my experience (though both are despressingly verbose). You can always macro-ify the lambda wrapping in C++14:

#define WRAP_FUN(f) [](auto&&... args) -> decltype(auto) { return f(std::forward<decltype(args)>(args)...); }

so that this becomes:

std::pop_heap(openlist_min_f.begin(), openlist_min_f.end(), WRAP_FUN(Node::HasGreaterF));