Passez-vous par référence, référence constante, référence de rvalue ou référence de rvalue constante?

RValues ​​peut se lier à des références de rvalue et des références Cons-LValue, par exemple xxx pré>

mais la rvalue ne peut pas se lier aux références de lvalue non constituées. La résolution de la surcharge préfère la liaison des temporaires vers RValue-Refs sur les reliures à la const-la liaison à Const Lvalue Refs: P>

paramCheck("");         // a string literal is an lvalue (!)
                        // see [expr.prim.general]/1
                        // but it is implicitly converted to a `std::string`,
                        // creating a `string` temporary, a rvalue

paramCheck(string{""}); // a temporary is an rvalue

string s3{""};
paramCheck(s3);         // the variable `s3` is an lvalue of type `string`

const string s4{""};
paramCheck(s4);         // the variable `s4` is an lvalue of type `const string`

//Illegal
//string& s{""};        // can't bind a temporary to a non-const lvalue ref
//paramCheck(s);

const string& s5{s3};
paramCheck(s5);         // the variable `s5` is a lvalue of type `const string`

string&& s6{""};        // binding a temporary to a rvalue-ref (allowed)
paramCheck(s6);         // the variable `s6` is an lvalue (!) - it has a name

//Illegal
//const string&& s{s1}; // `s1` has not been declared
//onstFP(s);

//Reference test
string a = s3;          // copy the contents of `s3` to a new string `a`
a = "a changed s3";     // overwrite contents of `a`
cout << s3;

{
string& b = s3;         // `b` refers to `s3` now (like an alias)
b = "b changed after assigning s3\n";
cout << "s3 is now " <<s3;

b = s4;                 // copy the contents of `s4` to `b` (i.e. to `s3`)
b = "b changed after assigning s4\n";
cout << "s3 is now " <<s3;
cout << "s4 is now " <<s4;
}

Si nous passons une expression constante, il déclenche toujours une référence de rvalue non constante? Sous quelle condition il va déclencher une référence de rvalue constante (et pourquoi S6 ne le triggente pas?)

Pour une expression constante? Rien. La seule fois où quelque chose se liera à const && sera s'il est déjà const . Et même alors, cela nécessitera une distribution explicite s'il s'agit d'une variable (voir ci-dessous).

Pourquoi une référence non constante et une référence de rvalue constante sont illégales?

Je vais supposer que vous parlez de ceux-ci: xxx

Le premier est illégal car "" n'est pas un std :: chaîne variable. Par conséquent, il doit construire un std :: chaîne temporaire de "" . s est une référence non-const à une chaîne existante variable . Vous ne pouvez pas faire une référence non-const à une référence temporaire, car une variable n'est pas une variable.

La seconde est illégale parce que (ignorant le fait que S1 n'existe pas ) C ++ ne vous permet pas d'obtenir une référence de valeur R à une variable sans conversion explicite . C'est ce que std :: déplacer est pour. const string && s {std :: move (S3)} fonctionne juste bien.

Je m'attendais à ne pas changer S3, mais pourquoi B dans la portée intérieure peut changer S3? Si l'attribution d'un nouvel objet S3 à B est attribuant une nouvelle référence, pourquoi, lorsque j'affecte S4 à elle et S3 a changé et S4 est vide ensuite?

Tout d'abord, vous pouvez modifier S3 bien. B est un référence à S3 ; Ils sont deux noms pour le même objet. Quant au reste, vous ne pouvez pas modifier quel objet est référencé par B après B est créé. B Démarre le référencement de référence S3 , il sera donc toujours le faire. Ainsi, b = s4 signifie copier s4 dans tout objet est référencé par b , qui est s3 .

S4 est vide après parce qu'il était toujours vide . Vous avez attribué la chaîne vide à elle. Donc, c'est vide.