Why an Rvalue Reference is Turned into Lvalue Reference by a Universal Reference

Question

I suppose when a universal reference parameter is matched with an rvalue reference argument, an rvalue reference argument is returned. However, my testing shows that the rvalue reference is turned into a lvalue reference by the universal reference function template. Why is it so?

#include <iostream>
#include <type_traits>
using namespace std;
template <typename T>
T f1(T&&t) {  //<-----this is a universal reference
  cout << "is_lvalue reference:" << is_lvalue_reference<T>::value << endl;
  cout << "is_rvalue reference:" << is_rvalue_reference<T>::value << endl;
  cout << "is_reference:"        << is_reference<T>::value        << endl;
  return t;
}
void f2(int&& t) {
  cout << "f2 is_lvalue reference:" << is_lvalue_reference<decltype(t)>::value << endl;
  cout << "f2 is_rvalue reference:" << is_rvalue_reference<decltype(t)>::value << endl;
  cout << "f2 is_reference:" << is_reference<decltype(t)>::value << endl;
  f1(t);

}

int main()
{
  f2(5);
  return 0;
}

In both GCC and VC++2010, this is the result:

f2 is_lvalue reference:0
f2 is_rvalue reference:1
f2 is_reference:1
is_lvalue reference:1
is_rvalue reference:0
is_reference:1

In other words, the parameter t in f2 was an rvalue reference, but when passed to f1, the parameter became a lvalue reference. Shouldn't it retain the rvalue-ness in f1?

what are the specific rules related to universal reference? Scott Meyers, in his book, just said rvalue to rvalue reference, lvalue to lvalue reference — JavaMan, Dec 28 '16 at 11:20

Edgar Rokjān · Answer 1 · 2016-12-28T13:10:20.773

8

The reason is that named rvalue references are treated as lvalues.

You should use std::move inside f2 when passing t to f1 to retain rvalueness:

void f2(int&& t) {
    f1(std::move(t));
}

Here you can find a good explanation.

edited Dec 28 '16 at 13:10

answered Dec 28 '16 at 11:18

Edgar Rokjān

17,245
4
40
67

The link which you shared has an example at the very last `Derived(Derived&& rhs) : Base(std::move(rhs)) // good, calls Base(Base&& rhs) { // Derived-specific stuff }`. Now, suppose `class Derived` had data_member `int x;`. Please specify how rhs can now be used in assignment `this->x=rhs.x`. Since its a copy constructor so, `Derived` data needs to copied from the `rhs` to `this`.But since `rhs` is `move`d so, i guess it will not be valid to use it any more. – sameerkn Dec 28 '16 at 11:39
ok, std::move() casts its argument to rvalue. But what is the type of the rvalue formed by this expression `std::move(t)`? rvalue of type `int&&` or rvalue of type `int`? – JavaMan Dec 28 '16 at 14:25
@JavaMan rvalue of type `int`. Only expressions have value categories, and expressions cannot have reference types. – Cubbi Dec 28 '16 at 16:22

score 3 · Answer 2 · answered Dec 28 '16 at 13:14

Calling f1(t), the argument is the expression t. Not static_cast<decltype(t)>(t) or something. Your examination of decltype(t) has nothing to do with the call of f1(t).

The expression t has type int and value category lvalue. (A rule of thumb is that if you can take the address of an expression then it is an lvalue, and you can certainly write &t). The "information" that a reference variable was originally declared as a reference is only visible via a decltype examination.

Since f1 is called with an lvalue, T is deduced to int&.

NB. You possibly want f1 to also use decltype(t) rather than T, if you ever want to see is_rvalue_reference being true in f1. For rvalue arguments, T deduces to a non-reference type, e.g. if you fix f2 by making it do f1(std::move(t)); then f1's T is int and decltype(t) in f1 is int&&.

score 0 · Answer 3 · answered Dec 28 '16 at 14:45

0

After studying the C++11 standard, I have a vague idea on what was going on after my f1(t); in f2. I describe it here to see if I got it right:

In f2, t is an lvalue of type int&& (not int, this is an important difference)
the call f1(t); causes type to be deduced like this:

2.1 when T in f1 is given an lvalue, it is deduced as a reference of that lvalue's type orint&& &

2.2 reference collapsing causes int&& & to become int &. This is the value of T.
Since the parameter of f1 is declared as T&&, the type of parameter t in f1 is int & &&. So reference collapsing occurs a second time to deduce the type of t as int &.
Hence T=int & and type of parameter t is int &. i.e. parameter t is an lvalue of type int &

Any comment?

answered Dec 28 '16 at 14:45

JavaMan

4,954
4
41
69

1

There is no reference collapsing in step 2. The type of the _variable_ `t` is `int&&`, while the type of the _expression_ `t` is `int`. This is just how references work and have always worked, regardless of value category, even before rvalue references were added to the language. – Oktalist Dec 28 '16 at 16:10
in that case, what is the value of `T` in step 2? Shouldn't it be `int&& &` instead of `int &`? If T is `int&& &`, isn't that we have to collapse it to get the parameter type? – JavaMan Dec 28 '16 at 16:20
`T` is not involved in step 2. `f1` is called with an lvalue expression of type `int`, so in step 3, `T` is deduced as `int&`, so `T&&` is `int& &&` which collapses to `int&`. – Oktalist Dec 28 '16 at 17:57

jiadong · Answer 4 · 2021-01-17T22:30:35.157

use the std::forward to keep t as rvalue.

void f2(int&& t) {
  //....
  f1(std::forward<int>(t));
}

The t argument is passed as rvalue and deduced as type int. (see how the deduction is done here )

std::forward(t) returns a rvalue of type int&& so that calls f1(int&&)

without std::forward(t), f1(t) takes the argument of type int and calls f1(int&)

UPDATE: Please be aware of the difference between

 is_lvalue_reference<T> and is_lvalue_reference<decltype<t>>.

In the template, T is deduced based on the function argument, whereas the value category of t is always lvalue in f2 and

forward<int>(t) and move(t)

are always rvalue.

#include <iostream>
#include <type_traits>

class A {};


template <typename T>
T f0(T& t) {  //<-----this is a universal reference
    std::cout<< "f0 lvalue"<<'\n';

    // take T as template argument, it is type int, so not rvalue, not lvalue.
//  std::cout << "is_lvalue reference:" << std::is_lvalue_reference<T>::value << std::endl;
    std::cout << "is_lvalue reference:" << std::is_lvalue_reference<T>::value << std::endl;
    std::cout << "is_rvalue reference:" << std::is_rvalue_reference<T>::value << std::endl;
    std::cout << "is_reference:"        << std::is_reference<T>::value        << std::endl;
    return t;
}

template <typename T>
T f0(T&&t) {  //<-----this is a universal reference
    std::cout<< "f0 rvalue"<<'\n';
    std::cout << "is_lvalue reference:" << std::is_lvalue_reference<T>::value << std::endl;
    std::cout << "is_rvalue reference:" << std::is_rvalue_reference<T>::value << std::endl;
    std::cout << "is_reference:"        << std::is_reference<T>::value        << std::endl;
    return t;
}

template <typename T>
T f1(T& t) {  //<-----this is a universal reference
    std::cout<< "f1 lvalue"<<'\n';

    // take T as template argument, it is type int, so not rvalue, not lvalue.
//  std::cout << "is_lvalue reference:" << std::is_lvalue_reference<T>::value << std::endl;
    std::cout << "is_lvalue reference:" << std::is_lvalue_reference<decltype(t)>::value << std::endl;
    std::cout << "is_rvalue reference:" << std::is_rvalue_reference<decltype(t)>::value << std::endl;
    std::cout << "is_reference:"        << std::is_reference<decltype(t)>::value        << std::endl;
    return t;
}

template <typename T>
T f1(T&&t) {  //<-----this is a universal reference
    std::cout<< "f1 rvalue"<<'\n';
    std::cout << "is_lvalue reference:" << std::is_lvalue_reference<decltype(t)>::value << std::endl;
    std::cout << "is_rvalue reference:" << std::is_rvalue_reference<decltype(t)>::value << std::endl;
    std::cout << "is_reference:"        << std::is_reference<decltype(t)>::value        << std::endl;
    return t;
}

void f2(int&&t) {  //<-----this is a universal reference
    std::cout<< "f2 rvalue"<<'\n';
    std::cout << "is_lvalue reference:" << std::is_lvalue_reference<decltype(t)>::value << std::endl;
    std::cout << "is_rvalue reference:" << std::is_rvalue_reference<decltype(t)>::value << std::endl;
    std::cout << "is_reference:"        << std::is_reference<decltype(t)>::value        << std::endl;


    f1(std::forward<int>(t));   // T is deduced as int for f(T&&), type int is not rvalue, nor lvalue, t is rvalue
    f1(std::move(t));           // T is deduced as int for f(T&&), type int is not rvalue, nor lvalue, t is rvalue
    f1(t);                      // T is deduced as int for f(T&),  type int is not rvalue, nor lvalue, t is lvalue
                                //if f1(T&) not exist, then f1(t) will call f1(T&&), T is deduced as int&, type int& is lvalue, t is lvalue


    f0(std::forward<int>(t));   // T is deduced as int for f(T&&), type int is not rvalue, nor lvalue, t is rvalue
    f0(std::move(t));           // T is deduced as int for f(T&&), type int is not rvalue, nor lvalue, t is rvalue
    f0(t);                      // T is deduced as int for f(T&),  type int is not rvalue, nor lvalue, t is lvalue
                                //if f0(T&) not exist, then f0(t) will call f0(T&&), T is deduced as int&, type int& is lvalue, t is lvalue
}




void test_rvalue()
{

    f2(5);
    std::cout << std::boolalpha;
    std::cout << std::is_lvalue_reference<A>::value << '\n';        // A is not lvalue
    std::cout << std::is_rvalue_reference<A>::value << '\n';        // A is not rvalue
    std::cout << std::is_lvalue_reference<A&>::value << '\n';       // A& is lvalue
    std::cout << std::is_rvalue_reference<A&&>::value << '\n';      // A&& is rvalue
    std::cout << std::is_lvalue_reference<int>::value << '\n';      // int is not lvalue
    std::cout << std::is_rvalue_reference<int>::value << '\n';      // int is not rvalue
    std::cout << std::is_lvalue_reference<int&>::value << '\n';     // int& is lvalue
    std::cout << std::is_rvalue_reference<int&&>::value << '\n';    // int&& is rvalue

}

Why an Rvalue Reference is Turned into Lvalue Reference by a Universal Reference

4 Answers4

Linked