I had this usage of bind1st
but I upgrade my project to C++17 as bind1st
is removed.
How can I replace bind1st
in the following statement?
Lambda?
DBManager::Instance().FuncQuery(std::bind1st(std::mem_fn(&CGuild::LoadGuildData), this), "SELECT master, level, exp, name, skill_point, skill, sp, ladder_point, win, draw, loss, gold FROM guild WHERE id = %u", m_data.guild_id);
Just use std::bind:
std::bind(std::mem_fn(&CGuild::LoadGuildData), this, std::placeholders::_1)
And you can remove the superfluous std::mem_fn
too:
std::bind(&CGuild::LoadGuildData, this, std::placeholders::_1)
With lambda, you might replace
std::bind1st(std::mem_fn(&CGuild::LoadGuildData), this)
by
[this](auto&& data) {return this->LoadGuildData(data);}
which give at the end something like:
DBManager::Instance().FuncQuery(
[this](auto&& data) {return this->LoadGuildData(data);},
"SELECT master, level, exp, name, skill_point, skill, sp, "
"ladder_point, win, draw, loss, gold FROM guild WHERE id = %u",
m_data.guild_id);
There are two things you could do here. And I find it really unfortunate that the current state of affairs is so awkward.
The most direct substitution is to take your bind1st
and convert it exactly to bind
:
std::bind(&CGuild::LoadGuildData, this, std::placeholders::_1)
Or, if you use bind
semi-regularly, you probably will bring in the placeholders via using
in some form or other, so this becomes:
std::bind(&CGuild::LoadGuildData, this, _1)
This is actually strictly better than bind1st
since this forwards its argument, but bind1st
would not.
The other thing we could do is a lambda. And here, it depends on what LoadGuildData()
does exactly. If it returns an object and you don't care about how this bound callable gets used necessarily, you can just write:
[this](auto const& arg){ return LoadGuildData(arg); }
This will work, most of the time. But it's not exactly the same thing as the bind expression. If LoadGuildData()
returned something like an int&
, the bind expression would return an int&
, but this version returns an int
. That might not be important. It might be not be. But if it is, you have to add, at least:
[this](auto const& arg) -> decltype(auto) { return LoadGuildData(arg); }
This will either return a reference type or not a reference type depending on what LoadGuildData()
actually returns.
Now... the argument, arg
, might be required to be a modifiable reference, which necessitates
[this](auto&& arg) -> decltype(auto) { return LoadGuildData(arg); }
But sufficiently often, you might need something more. You might need to use this callable in a context that needs to check if it's callable. Right now, due to the rules of how this checking works - all the lambdas I've written will claim that they're callable with any argument at all. Regardless of what LoadGuildData()
actually takes. But if it's the wrong type, you'll get a hard compile error. Unfortunate.
So what you really need to do, to write a lambda that has the same behavior as the bind expression I wrote earlier, is:
[this](auto&& arg) -> decltype(LoadGuildData(std::forward<decltype(arg)>(arg))) {
return LoadGuildData(std::forward<decltype(arg)>(arg));
}
Actually, it's not quite the same behavior. This lambda is actually better in some ways - because the bind expression would not have worked if LoadGuildData()
were a member function template or an overload set or took a default argument - but the lambda works in all of these cases. Which is why it is so often recommend to use lambdas - they always work, they're usually the best solution, and they're sometimes the only solution.
But it's a huge mouthful, which is why so many code bases use macros. Like BOOST_HOF_RETURNS
:
#define FWD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
[this](auto&& arg) BOOST_HOF_RETURNS(LoadGuildData(FWD(arg)))
All of which is to say... we can't have nice things.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With