les rvalue reference

Version imprimable

13/05/2008, 14h29
yan

les rvalue reference
Bonjour,
je cherche quelques explications sur les rvalue qui seront utilisées dans la prochaine version du C++.

En gros, ce que j'ai compris est que l'on pourra utiliser une instance non nommée pour faire des opérations.
Par exemple on pourra passer en référence une instance d'un class créée sans nom
Code:

1 2 3 4 5 6 void f(A&& a) { ... } f(A());
Si j'ai bien compris, on pourra même faire des bug comme
Code:

1 2 if (0=x)
...
est-ce bien cela ou je n'ai pas compris ce que c'est??
merci
13/05/2008, 14h57
JolyLoic

"rvalue reference", tu veux dire ?

C'est un peu ça, mais ça va plus loin...

L'article http://www.artima.com/cppsource/rvalue.html est assez bien foutu sur le sujet.
13/05/2008, 15h05
koala01
Salut,

Généralement, une rvalue(Right VALUE) représente... toute expression pouvant se trouver à droite d'un opérateur d'affectation (ou de comparaison)

L'autre terme "concomitant" est la lvalue (Left VALUE) qui représente... toute expression pouvant se trouver à gauche d'un opérateur d'affectation (ou de comparaison)

Ainsi, quand tu fais
Code:

1 2 int i; i = 2;
i est une lvalue (se trouve à gauche de l'opérateur d'affectation) et 2 est une rvalue (se trouve à droite de l'opérateur d'affectation)

Si on parle d'expression ici, c'est parce que dans le cas d'un code proche de

Code:

i = obj1.getA()+obj1.getB()*obj1.getC();

tu te rend compte que pour évaluer la valeur à donner à i, il faut commencer:
1. obtenir la valeur renvoyée par getA
2. obtenir la valeur renvoyée par getB
3. obtenir la valeur renoyée par getC
4. multiplier la valeur obtenue en (2) par la valeur obtenue en (3)
5. additionner la valeur obtenue en (1) par le résultat de (4)
;)
13/05/2008, 15h34
yan
EN faite ma question viens de cette discutions :
http://www.developpez.net/forums/sho...83#post3254883
et c'est donc rvalue reference (je ne savait pas que rvalue était autre chose :aie:)

J'ai regardé un peu le lien et je me pose déjà des questions sur l'implementation du swap avec les rvalue reference
Code:

1 2 3 4 5 6 template <class T> swap(T& a, T& b) { T tmp(std::move(a)); a = std::move(b); b = std::move(tmp); }
Ce que je comprend est que T doit avoir un constructeur et un operateur = prenant une rvalue reference. Cela reviendrai à pouvoir partager une implémentation privé de la class, n'est ce pas?
par exemple :
Code:

1 2 3 4 5 template <class T> f(T& a) { T tmp(std::move(a)); a = 1; }
quand a sera affecté par 1, tmp le sera aussi c'est bien ça???
13/05/2008, 21h07
yan
de même
Code:

1 2 3 4 5 6 7 template <class T> f(T& a) { T tmp; //traitement sur tmp ... a = std::move(tmp); }
1- la memoire appartenant à a sera detruite si personne de l'utilise
2- a prendra la memoire de tmp,
3- tmp est détruit, aucune memoire n'est détruite.
C'est bien ca?
13/05/2008, 23h49
loufoque

Tout l'intérêt des rvalue references c'est de distinguer les rvalues des lvalues constantes, ce que le langage actuel ne permettait pas.

En particulier, on peut se permettre de modifier des rvalues pour transférer leur valeur, ce qu'on peut pas vraiment se permettre avec les lvalues (constantes ou non).
14/05/2008, 10h06
yan
Y as un truc que je ne pige pas .
Lors que l'on fera
Code:

1 2 T a,b; a = move(b);
a et b devront swapper leur mémoire???
Ou alors c'est juste l'exemple?
14/05/2008, 15h02
loufoque

Non, ça va caster b en rvalue, le but étant de déplacer b dans a.
Y'a pas de swappage puisqu'on déplace pas a dans b.
14/05/2008, 15h16
yan

Citation:

Envoyé par loufoque

Non, ça va caster b en rvalue, le but étant de déplacer b dans a.
Y'a pas de swappage puisqu'on déplace pas a dans b.

que va devenir b dans ce cas??
15/05/2008, 03h20
Klaim

Si j'ai bien compris, il ne sera pas touché, il sera juste dupliqué dan a.

(c'est bien ça?)
15/05/2008, 07h30
yan

Citation:

Envoyé par Klaim

Si j'ai bien compris, il ne sera pas touché, il sera juste dupliqué dan a.

(c'est bien ça?)

dupliqué == copié donc je dirait que non

Salut,

Voici un code qui j'espère va t'aider à mieux comprendre les rvalue reference:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#include <iostream>
#include <cstring>
 
class A
{
private:
  char *str;
  size_t length;
 
public:
  A() : str(0), length(0)
  {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
  }
  A(char const *s)
  {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
    str=new char[std::strlen(s)+1];
    length=std::strlen(s)+1;
    strcpy(str, s);
  }
  A(A const &a)
  {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
    str=new char[a.length];
    length=a.length;
    std::memcpy(str, a.str, length);
  }
  A(A &&a)
  {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
    length=a.length;
    a.length=0;
    str=a.str;
    a.str=0;
  }
  ~A()
  {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
    delete[] str;
  }
  A& operator=(A const &a)
  {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
    char *tmp=0;
    tmp=new char[a.length];
    std::memcpy(tmp, a.str, a.length);
    delete[] str;
    length=a.length;
    str=tmp;
    return *this;
  }
  A& operator=(A &&a)
  {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
    delete[] str;
    length=a.length;
    a.length=0;
    str=a.str;
    a.str=0;
    return *this;
  }
};
 
int main(void)
{
  A a;
  A b;
 
  b="toto"; //appel de A::operator=(A &&)
  a=std::move(b); //appel de A::operator=(A &&)
  A c(std::move(a)); //appel de A::A(A &&);
 
  return 0;
}

Ce code compile avec gcc 4.3.0 avec l'option -std=c++0x

15/05/2008, 14h15
loufoque

Citation:

que va devenir b dans ce cas??

Il deviendra "vide".
Bien entendu tout cela dépend de comment tu implémentes ton constructeur et ton opérateur d'affectation de déplacement...
15/05/2008, 14h22
yan
okok.
Donc lorque l'on fait a=std::move(b), a récupère les info de b et b est réinitialisé à zéro.

Du coup
dans l'exemple http://www.artima.com/cppsource/rvalue.html peut tu m'expliquer
Code:

1 2 3 4 5 6 7 8 9 10 // move semantics clone_ptr(clone_ptr&& p) : ptr(p.ptr) {p.ptr = 0;} clone_ptr& operator=(clone_ptr&& p) { std::swap(ptr, p.ptr); return *this; }
merci.
15/05/2008, 16h34
loufoque

Ça ressemble à une erreur. Il vaut mieux libérer l'ancienne valeur de suite que de la transférer à la rvalue (qui peut ne pas vraiment en être une).
Il y a d'ailleurs une autre erreur dans le code, si clone lève une exception ça peut laisser le clone_ptr dans un état indéterminé, ce qui est pas terrible.

C'est assez surprenant néanmoins vu les auteurs...
J'ai posté un message à ce sujet sur le forum associé à ce site.
15/05/2008, 16h45
yan

Citation:

Envoyé par loufoque

Ça ressemble à une erreur. Il vaut mieux libérer l'ancienne valeur de suite que de la transférer à la rvalue (qui peut ne pas vraiment en être une).
Il y a d'ailleurs une autre erreur dans le code, si clone lève une exception ça peut laisser le clone_ptr dans un état indéterminé, ce qui est pas terrible.

C'est assez surprenant néanmoins vu les auteurs...

merci beaucoup