除了将args转发到另一个函数外，还使用std :: forward

Question

I have a number of methods of the following form

foo(std::string const & name)
    if (name.empty()) {...}

I was trying to follow Scott Meyers' note on using universal references and std::forward to make a function that efficiently takes a number of string forms.

From example, I understand how to use std::forward to forward a function argument to another function, but what do I do about the name.empty() expression?

I think the answer is std::forward(name).empty() but I can find any documentation that actually says that.

Answer 1

Use std::forward only when you actually need to forward the value category. That is, std::forward is used to guarantee that if your function is called with an lvalue argument then it will call another function with an lvalue argument, and if your function is called with an rvalue argument then it will call another function with an rvalue argument.

In the case where you want to check whether a string is empty, it doesn't matter whether the argument was an lvalue or rvalue---the string::empty function should not behave differently. So you don't need std::forward . Instead, just name.empty() suffices.

Answer 2

There is an easy way to figure out when to use std::forward .

Imagine your incoming argument was, instead of a T&& t just a T t -- a value parameter instead of a forwarding reference. If you would call std::move(t) in the second case, calling std::forward<T>(t) in the first case is a good idea.

std::forward is a conditional move. It will invoke the move iff the reference was an rvalue passed in, and will do mostly nothing if it wasn't an rvalue.

The next question is, when should you move a value parameter?

Well, the first general rule is you should move a value parameter the last time you'll ever refer to it in its scope. You are marking its state as "scratch" and that it be recycled in that last operation.

There are a few other places to use move .

If you are breaking it down into individual components (like the parts of a tuple), and you know the access will be isolated to the part ( std::get<N> , or .member ), and there are no invariants that will be violated, then move will tell the code that the component can be torn out of the object. You can end up calling move on the same variable multiple times in this sense, but each time you are conceptually only moving one part of it.

This is sometimes distinct from calling move on the component itself, as std::get<i>(std::move(foo)) will behave differently than std::move( std::get<i>(foo) ) when foo contains reference parameters.