Discussion :

[yan]

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 :

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

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 :

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

1
2
 
if (0=x)

...
est-ce bien cela ou je n'ai pas compris ce que c'est??
merci

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

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

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

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 :

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

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)

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

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 :

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

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 :

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

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???

[yan]

de même

Code :

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

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?

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

[yan]

Y as un truc que je ne pige pas .
Lors que l'on fera

Code :

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

1
2
T a,b;
a = move(b);

a et b devront swapper leur mémoire???
Ou alors c'est juste l'exemple?

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

[yan]

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??

[Klaim]

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

(c'est bien ça?)

[yan]

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

[Montag]

Salut,

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

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

[loufoque]

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

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

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

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.

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

[yan]

Ç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