How to declare std::invoke_result of std::bind in C++? - c++

Question

I want to declare std::unique_ptr with custom deleter, which binds some arguments to the specific function:
using namespace std::placeholders;
using HandleDeleter = std::invoke_result_t<std::bind, _1, SOME_FLAG>; // !!!
using HandlePtr = std::unique_ptr<handle_t, HandleDeleter>;
void handle_destroy(handle_t *, int flags);
handle_t * raw_handle;
auto deleter = std::bind(handle_destroy, _1, SOME_FLAG);
HandlePtr ptr(raw_handle, deleter);
And this doesn't work because std::bind is a monstrous template construction on its own with unspecified return type.
How to properly declare HandleDeleter in my case?

Answer 1

std::bind is not a single callable, but a function-template. Thus, you would have to choose which one to pass to std::invoke_result_t, which is really messy.
Fortunately, there are better alternatives:
Use decltype:
using deleter_t = decltype(std::bind(handle_destroy, _1, SOME_FLAG));
Use template-argument-deduction for the class:
unique_ptr ptr(raw_handle, deleter);
Anyway, not using std::bind() is generally simpler, as well as more efficient due to hard-coding the function and argument used. Though you certainly are free to only hard-code part:
Use a lambda instead of std::bind(). In C++20 a stateless lambda will even become default-constructible:
auto deleter = [](handle_t* p){ handle_destroy(p, SOME_FLAG); };
Define your own custom deleter-class instead of using std::bind:
struct deleter_t {
constexpr void operator()(handle_t* p) const noexcept {
handle_destroy(p, SOME_FLAG);
}
};

Answer 2

And this doesn't work because std::bind is a monstrous template construction on its own with unspecified return type.
This is a hint: you're probably using the wrong tool for the job.
I would use a simple struct instead:
struct HandleDeleter
{
int _flag;
void operator()(handle_t* h) const
{
handle_destroy(h, _flag);
}
};
HandlePtr ptr(raw_handle, HandleDeleter{SOME_FLAG});
std::bind is not recommended in Modern C++. Use lambdas (or structs) instead. std::bind has several issues excellently explained in this talk by Stephan T. Lavavej “functional: What's New, And Proper Usage".