Discussion :

[oodini]

Hello,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int&& a = 5;

Quelqu'un pourrait-il m'éclairer ?

Merci.

[nibors]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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.

[nibors]

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é ^^

[jo_link_noir]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[dalfab]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[oodini]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[oodini]

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).

[foetus]

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 ], un rvalue c'est un temporaire.
Le problème du temporaire, c'est qu'on ne peut pas le modifier (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.

[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.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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’)
}

[dalfab]

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é.