What is the usage of std::forward in parameter passing?

Question

See the piece of code below(notice that s is a array with char instead of string):

#include <string>
#include <iostream>
#include <utility>

void func(std::string & s, char a) {
  std::cout << "here1" << std::endl;
  // ...
}

void func(std::string && s, char a) {
  std::cout << "here2" << std::endl;
  // ...
}

template <class T>
void foo(T && s) {
  std::cout << "foo2" << std::endl;
  func(s, ':');
  //func(std::forward<T>(s), ':');
}

int main(int agrc, char *argv[])
{
  //std::string s("a:b:c:d");
  char s[8] = "abcdefg";
  foo(std::move(s));
  std::string s2("abcd")
  foo(s2);
  return 0;  
}

If I replace func(s, ':') using std::forward, it makes no difference, the foo function will do the prefect forwarding without std::forward in this case.

Is there mis-understanding of 'prefect forwarding' with std::forward in C++11?

Note that you shouldn't be using `s` after it's been moved from. — chris, Jan 19 '14 at 17:27
[Both of the calls print `here1` for me](http://ideone.com/LE3qrQ). And with `std::forward` I get `here2` then `here1`, just as expected. — Joseph Mansfield, Jan 19 '14 at 17:29
@chris I disagree. The state of the object would be undefined, but still valid (especially `operator=`) http://stackoverflow.com/questions/7027523/what-can-i-do-with-a-moved-from-object — pmr, Jan 19 '14 at 17:29
@pmr, Good point, but better safe than something bad happening later. — chris, Jan 19 '14 at 17:31
your update is calling `foo(char* &&)` and `func(std::string &&)` due to implicit constructor of `std::string`. — yngccc, Jan 19 '14 at 17:44
Passing an array of `char`, which decays into `char*`, which then creates a temporary `string`, really complicates/messes up everything, completely masking the issue you are actually trying to test. — juanchopanza, Jan 19 '14 at 17:46
Why do you call the array `s`? When you have functions taking a `string` called `s`? That's really confusing. The moment you had to write a notice pointing this confusion out to us, you should have changed your mind and renamed the array `ar`! — Lightness Races in Orbit, Jan 19 '14 at 18:16
@LightnessRacesinOrbit, It's irrelevant now. It used to be moved and then passed with just `s` instead of `s2` existing. — chris, Jan 19 '14 at 18:29
@chris: Even in that version, I see no move. You know `std::move` doesn't perform any move, right? — Lightness Races in Orbit, Jan 19 '14 at 18:36
@LightnessRacesinOrbit, Yeah, I know, which makes it even sadder. You win. — chris, Jan 19 '14 at 18:41

pmr · Answer 1 · 2014-01-19T17:43:39.810

5

It makes a difference. In your case func(s, ':') will only ever call the overload of func that takes reference to a std::string.

The issue is that named variables and parameters are lvalues themselves and this is also the reason why std::forward exists in the first place.

In your example it has the appearance that the right overload is chosen for the first call to foo even if you don't use std::forward. This is just because you actually call foo with a char[] argument which is used to implicitly construct a temporary of std::string.

edited Jan 19 '14 at 17:43

answered Jan 19 '14 at 17:32

pmr

58,701
10
113
156

2

@xunzhang Your example is bad. Because in the first case `foo` uses an array type and constructs a temporary at the call site. This is why you believe the right overload is chosen. I fixed your example: http://ideone.com/btZd7Y – pmr Jan 19 '14 at 17:42

score 1 · Answer 2 · answered Jan 19 '14 at 17:35

Lets consider first case foo(std::move(s)). Inside of foo, s will be bind to rvalue. But since it has a name (s) it's not an rvalue anymore. So when you pass s to func it will be like passing lvalue to it - it will trigger here1 version. But if you will pass s via std::forward it will be rvalue once again.

In second case s is lvalue reference when foo is entered, so it doesn't change anything whether you pass it directly or via std::forward. You would need to use std::move to get rvalue out of s again.

What is the usage of std::forward in parameter passing?

2 Answers2