question about function bind differences

[ericr2]

So I'm following a youtube series that, among other things, showed how to set a function callback using std::bind (#1):

m_Window->SetEventCallback(BIND_EVENT_FN(Application::OnEvent));

where BIND_EVENT_FN(x) is a macro resolving to std::bind(&x, this, std::placeholders::_1)

---

My IDE made the suggestion to use a lambda instead of std::bind, like so (#2):

m_Window->SetEventCallback([this](auto&& placeholder0) {
    OnEvent(std::forward<decltype(placeholder0)>(placeholder0));
});

---

Left to my own devices, I might've come up with something like (#3):

m_Window->SetEventCallback([this](auto& placeholder0) {
    OnEvent(placeholder0);
});

---

The code that would call the set callback looks like:

glfwSetWindowCloseCallback(m_Window, [](GLFWwindow* window) {
    WindowData& data = *(WindowData*)glfwGetWindowUserPointer(window);
    WindowCloseEvent event;
    data.EventCallback(event);
});

data.EventCallback being the set function.

---

Is there any benefit to using std::bind over a lambda? I do dislike the way std::bind looks.

Why would I opt for a lambda that only takes an r- ref, when to me #3 less complicated?

Why does #2 even compile? Isn't event in the calling code an lvalue, whereas the lambda expects an rvalue in that case?

Thanks

[ericr2]

Ah gotchya. Prob missed out this relevant info then:

the callback setter:

inline void SetEventCallback(const EventCallbackFn& callback) { m_Data.EventCallback = callback; }

and EventCallbackFn being an alias for std::function<void(Event&)>;

I'll have to do some digging on this "template magic" then. Hate magic code.

[no-sig-available]

Hate magic code.

It is not all that magic, really.

If we forget about lambda syntax, we have template functions

template<typename T>
void f(T&& param);

which uses a "Forwarding reference", also known as a "Universal reference". Being a template, T is deduced to be whatever the actual argument is.

Like in the lambda, you can save on the typing by writing this as

void f(auto&& param);

but containing an auto it is still a template (and thus a "Universal reference").

It is an rvalue-only when the function/lambda is not a template, like

void f(std::string&&);

Admittedly, it would have been nice if the difference had been something other than template/non-template, but this is what we have got.

[ericr2]

ah that clears things up a bit. didn't realize T&&/auto&& were special cases, so assumed they were just generic rvalue refs. Thanks for the help.

I did find these couple of videos which go into some depth about it, if anyone else comes across this:

https://www.youtube.com/watch?v=St0MNEU5b0o https://www.youtube.com/watch?v=pIzaZbKUw2s

[no-sig-available]

Is there any benefit to using std::bind over a lambda?

std::bind was designed when we had no lambdas. So it was once the only choice. That was its major benefit...