Question

This is the code from C++11 Notes Sample by Scott Meyers,

int x;
auto&& a1 = x;             // x is lvalue, so type of a1 is int&
auto&& a2 = std::move(x);  // std::move(x) is rvalue, so type of a2 is int&&

I am having trouble understanding auto&&.
I have some understanding of auto, from which I would say that auto& a1 = x should make type of a1 as int&

Which from Quoted code, seems wrong.

I wrote this small code, and ran under gcc.

#include <iostream>

using namespace std;

int main()
{
    int x = 4;
    auto& a1 = x;           //line 8
    cout << a1 << endl;
    ++a1;
    cout << x;
    return 0;
}

Output = 4 (newline) 5
Then I modified line 8 as auto&& a1 = x;, and ran. Same output.

My question : Is auto& equal to auto&&?
If they are different what does auto&& do?

Answer 1

The code is right. auto&& p = expr means the type of p is T&& where T will be inferred from expr. The && here indicates a rvalue reference, so e.g.

auto&& p = 1;

will infer T == int and thus the type of p is int&&.

However, references can be collapsed according to the rule:

T& &   == T&
T& &&  == T&
T&& &  == T&
T&& && == T&&

(This feature is used to implement perfect forwarding in C++11.)

In the case

auto&& p = x;

as x is an lvalue, an rvalue reference cannot be bound to it, but if we infer T = int& then the type of p will become int& && = int&, which is an lvalue reference, which can be bound to x. Only in this case auto&& and auto& give the same result. These two are different though, e.g.

auto& p = std::move(x);

is incorrect because std::move(x) is an rvalue, and the lvalue reference cannot be bound to it.

Please read C++ Rvalue References Explained for a walk through.