Hi,
 

 
Dans ce genre de code std::move est utilisé dans le constructeur de move par exemple pour initialiser la variable name, ma question est pourquoi?
Le fait que x soit une rvalue n'implique pas que x.name en soit une ?

un membre de rvalue ne peut etre qu'une rvalue lui même hein

c'est ce qui me parraissait le plus logique en effet, mais alors pourquoi faire du std::move ici ?

bah car tu peut guère faire autrechose sur une rvalue

mais le move à la base ça sert à rendre une lvalue rvalue, donc si c déjà une rvalue pourquoi mover??

move preserve la rvalueness d'une rvalue. Qui te dit qu'un de membres là n'a pas lui même un constructeur par move. Si tu passais x.name par lvlaue, il en tomberais pas ou il faut.

sauf que x est forcément une r-value, car on est à cet endroit dans le constructeur de move de x.

je parle des move-constructor de base, vec et name ...

oui mais - sauf si on ne se comprend pas- , si on est sûr que x est une r-value, si comme tu me la confirmer "un membre de rvalue ne peut etre qu'une rvalue lui même" et bien je ne vois toujours pas l'intérêt de faire du move par exemple là :  
 
 
 
vec(std::move(x.vec)) : x est r-value=> x.vec est r-value,  so why move ??
 
 
EDIT: à priori l'explication serait que, bien que déclaré comme r-value parameter,  x est traité comme l-value pour des raisons de sécurité, si quelqu'un en sait d'avantage je suis preneur
 
void g(const A& );
void g(A&& );
 
void f(A&& a)
{
 
    g(a);  // calls g(const A& )
}
 
à priori c'est pour éviter des histoires de double move et donc de contenu "voler" deux fois

car une named rvalue est une lvalue

voial des qu'une rvaleu a un nom, ca devient une lvalue

de plus il me semble qu'il vaut mieux se contenter dans la pluspart des cas d'un operateur d'assignement par value et qui swap plutot que d'en déclarer un prenant une rvalue reference