Trouble : Named rvalue

Hello,

J'ai du mal à trouver un sens et un intérêt à une déclaration telle que :

Code:

---

int&& a = 5;

---

Quelqu'un pourrait-il m'éclairer ?

Merci.

Bonjour,

je pense qu'il s'agit d'une histoire de rvalue/lvalue

par exemple :

void func(int toto);

peut etre appelé avec des lvalue et rvalue.
c'est a dire :

Code:

---

1 2 3 4

int n = 1; func(n); // ca marche func(1); //ca marche

---

void func(int& toto);

peut etre appelé avec des lvalue seulement.
c'est a dire :

Code:

---

1 2 3 4

int n = 1; func(n); // ca marche func(1); // marche pas

---

void func(int&& toto);

peut etre appelé avec des rvalue seulement.
c'est a dire :

Code:

---

1 2 3 4

int n = 1; func(n); // marche pas func(1); // ca marche

---

J'ai bien compris les rvalue dans le cadre des arguments de fonction.

Ce qui m'intrigue, ce sont les autres rvalues nommées, qui ne sont pas des arguments de fonction.

Citation:

---

Envoyé par oodini

J'ai bien compris les rvalue dans le cadre des arguments de fonction.

Ce qui m'intrigue, ce sont les autres rvalues nommées, qui ne sont pas des arguments de fonction.

---

Ah pardon j'avais mal compris ta question. C'est une bonne question effectivement, peut etre pour forcer une fonction func(int&& toto) a accepté func(a) ? C'est une idée comme une autre je n'ai pas testé ^^

Cela ne sert pas à grand chose et ne force pas le passage de paramètre en rvalue (c'est toujours passé par référence).

Par contre, c'est utile avec des types proxys et du AAA.

Code:

---

1 2 3 4 5 6

std::vector<int> v1; std::vector<bool> v2;   for (int & x : v1){} // ok for (bool & x : v2){} // ne compile pas, *v.begin() est un type proxy (une classe std::vector<bool>::reference) non un bool &.

---

Code:

---

1 2 3

for (auto && x : v1){} // ok, x est un int& for (auto && x : v2){} // ok, x est un type proxy

---

Bonjour,

La r-reference est une référence qui s'initialise sur un temporaire (rvalue) ou une variable qui peut être dépecée (xvalue).
Cela est utile en passage de paramètre en particulier pour des optimisations.

L'intérêt dans une variable locale est de bloquer une référence sur un temporaire que l'on va modifier!

Code:

---

1 2 3 4 5 6 7 8 9 10

Objet fct() {} Objet && x = fct(); // fct a retourné un objet, x permet de l'utiliser plus loin Objet &y = fct(); // erreur, on ne peut pas référencer un temporaire Objet const& z = fct(); // ok, la référence constante est toujours possible Objet u = fct(); // ok, mais une opération de recopie a dû être effectuée   ++x.a; ++y.a; // erreur ++u.a; std::cout << x.a << z.a << u.a; //ok

---

La r-référence permet donc d'accéder de manière optimale à un temporaire que l'on peut modifier. Ce cas est rare (proxies) ou souvent idiot, il faut préférer la l-référence constante.

Bonjour,

Mais pourquoi la dernière ligne du code suivant compile-t-elle, alors qu'on affecte à une lvalue une rvalue ?

Code:

---

1 2 3

int j = 3; int&& i = 5; i = j;

---

Est-ce comme à l'intérieur de fonctions ?
i est-il utilisable comme une l-value après son initialisation ?

Bon, OK, je crois que j'ai compris : la nature rvalue est fugace. Une fois qu'on a passé l'expression de la déclaration/définition, on passe à une nature de lvalue.

Cette rvalueness ne persiste pas dans le temps.

Cette histoire de rvalue n'est donc vraiment été créée QUE pour permettre la surcharge de fonction.
Alors que les lvalue peuvent être utilisées pour autre chose (création d'alias, notamment).

Non je pense que tu te trompes: What are rvalues, lvalues, xvalues, glvalues, and prvalues?

En gros si je comprends bien [mais je ne maitrise pas les cas particuliers :wow:], un rvalue c'est un temporaire.
Le problème du temporaire, c'est qu'on ne peut pas le modifier :mrgreen: (et en théorie ni le lire)

Mais,

• Si on retourne par valeur, c'est un prvalue: il y a recopie
• Si on attrape en const reference (C++03), c'est un xvalue. Sa durée de vie a été étendue pour être seulement lu
• Si on attrape en && (C++11), c'est une rvalue reference et on pourra modifier le temporaire: il y a transfert (move semantic) si je ne me trompe pas.

Et le glvalue, j'ai l'impression que c'est pour exprimer un passage de paramètres non par valeur.

Les comportements de T et T&& sont identiques à travers une variable: on manipule un T&. Bah oui, toutes les variables sont des lvalues. D'où l'usage systématique de std::move en cascade quand on propage l'ownership et de std::forward dans les tempates.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#include <iostream>   struct A{ int foo() & { return 1; } int foo() && { return 2; } };   int main() { A a{}; A && ra{}; std::cout << a.foo() << '\n' // 1 << ra.foo() << '\n' // 1 << A{}.foo() << '\n' // 2 << static_cast<A&&>(a).foo() << '\n' // 2 << static_cast<A&&>(ra).foo() << '\n' // 2 ; //decltype(a){} = 1; // no match for ‘operator=’ (operand types are ‘A’ and ‘int’) //decltype(ra){} = 1; // no match for ‘operator=’ (operand types are ‘A’ and ‘int’) }

---

Citation:

---

Envoyé par jo_link_noir

Les comportements de T et T&& sont identiques à travers une variable: on manipule un T&. Bah oui, toutes les variables sont des lvalues. D'où l'usage systématique de std::move en cascade quand on propage l'ownership et de std::forward dans les tempates.

---

Oui, c'est important d"avoir cela à l"esprit.
Object x = ...;
Object &y = ...;
Object const&z = ...;
Object &&u = ...;
Ces quatre variables sont toutes des l-values (ces sont des variables, elles ont bien un nom).

La différenciation n'a de sens qu'au moment de l'initialisation

• x s'initialise sur tout (elle a son propre contenu)
• y s'initialise obligatoirement sur une l-value
• z s'initialise sur tout (si pr-value ou transformation nécessaire, le temporaire reçu qui normalement disparaît à la fin de l'expression est maintenu jusqu'à la fin de vie de z).
• u s'initialise obligatoirement sur une r-value.

A l'utilisation, on donc leur affecter tout ce que l'on veut (xvalue, prvalue, lvalue, glvalue, rvalue).
les opérations sur y z u agissent sur le contenu référencé.