not understanding double forwarding of an lvalue - when passed by value - c++

Question

#include <iostream>
#include <vector>
#include <type_traits>
#include <utility>
using namespace std;
template <typename Func, typename... Args>
void proxy(Func f, Args&&... args) {
f(std::forward<Args>(args)...);
}
void real_func(vector<int> v) {
cout << "size: " << v.size() << endl;
}
void multicast_func(vector<int> v) {
proxy(real_func, std::forward<vector<int>>(v));
proxy(real_func, std::forward<vector<int>>(v));
}
int main()
{
vector<int> ints = {1, 2, 3};
multicast_func(ints);
return 0;
}
and the output is:
size: 3
size: 0
why isn't it 3, 3? at what point does this lvalue become an rvalue and gets moved-from?

Answer 1

std::forward is intended to be used with universal references.
The parameter of multicast_func is not an universal reference, so std::forward makes no sense:
void multicast_func(vector<int> v) {
proxy(real_func, std::forward<vector<int>>(v));
proxy(real_func, std::forward<vector<int>>(v));
}
In this case, it effectively acts like std::move (because the template parameter is not an (lvalue) reference).

Answer 2

The prototype for std::forward called in your code is:
template< class T >
constexpr T&& forward( typename std::remove_reference<T>::type& t ) noexcept;
When called with non-reference type, it effectively makes an rvalue reference out of the argument, which than is moved from. std::vector is guaranteed to be empty after being moved from it, so size becomes 0.

Answer 3

at what point does this lvalue become an rvalue and gets moved-from?
At the 1st time proxy is invoked v is converted to an rvalue, and then gets moved-from when passed to real_func.
void multicast_func(vector<int> v) {
// the return type of std::forward is T&&, i.e. vector<int>&& here
// for functions whose return type is rvalue reference to objec, the return value is an rvalue
// that means v is converted to an rvalue and passed to proxy
proxy(real_func, std::forward<vector<int>>(v));
// v has been moved when passed to real_func as argument
proxy(real_func, std::forward<vector<int>>(v));
}
The usage in proxy is the general usage of std::forward; according to the argument is an lvalue or rvalue, the template parameter will be deduced as T& or T. For T& std::forward will return an lvalue, for T std::forward will return an rvalue, so the value category is preserved. When you specify the template argument solely such capacity is lost.

Answer 4

std::forward, when not given a reference type, will cast provided object to an rvalue. This means the first call to
proxy(real_func, std::forward<vector<int>>(v));
will make v an rvalue which means it will move it into real_func. The second call then uses that moved from object and you get the size of 0 since it has been emptied.
This makes sense if we look at the function. The version of std::forward you are calling is
template< class T >
constexpr T&& forward( typename std::remove_reference<T>::type& t ) noexcept;
Since you passed std::vector<int> for T that means it will return a std::vector<int>&&. So, even though v is an lvalue, it is converted to an rvalue. If you want to maintain the lvalue-ness of v then you need to use std::vector<int>&. That gives you std::vector<int>& && and reference colapse rules turns that into std::vector<int>& leaving you with an lvalue.

Answer 5

In the first call of proxy, the parameter vector<int> v(in function real_func) is move constructed from the rvalue, so v (in function multicast_func) has been empty.
But if you change the type of paremeter as cosnt vector<int> &, the result will be 3, 3. Because the move constrctor has not been called.
void real_func(const vector<int>& v) {
cout << "size: " << v.size() << endl;// the output is 3, 3
}