Que fait auto &&?

Question

C'est le code de C++11 Notes de l'Échantillon par 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&&

Je vais avoir du mal à comprendre auto&&.
J'ai une certaine compréhension de l' auto, à partir de laquelle je dirais qu' auto& a1 = x doivent faire type d' a1 comme int&

Qui, de la Cité de code, semble erroné.

J'ai écrit ce petit code, et a couru sous gcc.

#include <iostream>

using namespace std;

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

Sortie = 4 (newline) 5
Puis j'ai modifié la ligne 8 auto&& a1 = x;, et a couru. Même sortie.

Ma question : Est - auto& égal à auto&&?
S'ils sont différents, qu'est - auto&& faire?

Answer 1

Le code est bon. auto&& p = expr signifie que le type d' p est T&& où T sera déduit à partir de expr. L' && ici indique une référence rvalue, donc par ex.

auto&& p = 1;

va conclure T == int , et donc le type d' p est int&&.

Toutefois, les références peuvent être réduits selon la règle:

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

(Cette fonction est utilisée pour mettre en œuvre le transfert parfait en C++11.)

Dans le cas

auto&& p = x;

en tant que x est une lvalue, une référence rvalue ne peut pas être lié à cela, mais si nous en déduisons T = int& , puis le type d' p deviendra int& && = int&, ce qui est une lvalue de référence, qui peut être lié à l' x. Seulement dans ce cas - auto&& et auto& donnent le même résultat. Ces deux sont différent, par exemple

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

est incorrect, car std::move(x) est une rvalue, et la lvalue de référence ne peut pas être lié à elle.

Veuillez lire C++ Références Rvalue Explique pour une promenade à travers.