Forward Signed Understanding with airSlate SignNow

Forward signed understanding

Okay hi I'm Paul Dreik. I'm going to speak about std::forward. This is going to be a beginners talk. std::forward was introduced in C++11 and it's coupled to move semantics, rvalues, lvalues, all that stuff. I'm gonna try to demonstrate with this live coding. See if we can get it big enough, is this okay? Let's clean up here a bit. This is my example program. I have a struct. I have a function taking a reference to a struct. So far so good. If I create an object and then invoke f() on it, I'll try to compile. You can see here down at the bottom (I will try to make it bigger). You see, the function gets called that's what we expect so that's good. So what now if we use a temporary object. This will be an rvalue. We get a compiler error. That's because we have a non const reference which won't bind to an rvalue. So we will add an rvalue overload. Okay, that should do it. Let's compile and run, yeah you can see down here at the bottom that it selects the second overload so this is good, this is what we expect. So now we'll see: what if we have a wrapper so in this wrapper I will invoke f. :-( Let's try this and see if it compiles, yes. The reason for having a wrapper: maybe you want to run f in a try-catch or maybe you want to log something then run f, whatever, there are many reasons so let's now try to invoke wrap() instead of f(). On the lvalue I can see down here: everything works as usual, we get the first overload so that's good. Now let's try the second one on an rvalue (Oh I forgot to change it) I think I'm getting some kind of help here. Okay, that looks better Okay so now when I invoked wrap on an rvalue we got the first overload so that's wrong because that's not the same thing as calling f directly. So this is where we're gonna use std::forward. We see, this double ampersand, this is a forwarding reference. It was called universal reference but now it's called forwarding reference so I'm gonna use std::forward on T so what this std::forward does is that it preserves the value category of it's argument. Let's try this now. I have the lvalue version it selects the first overload, that's good. And we invoke it on the rvalue. We get the the second overload. Now you see we have a generic function which selects the correct overload. This is what you use std::forward for. If you dig into this you can go quite deep but this is most of what you need to know about std::forward. I can note that you can't use std::move here because that would be the wrong thing, that would unconditionally make it an rvalue. std::forward is the right thing to do in this place. I...