Discussion :

[Invité]

Salut, j'aimerais savoir ce que fait std::move exactement, déplace t'il le contenu d'un pointeur ou d'une référence vers un autre pointeur ?

Est ce que ce code-ci va déplacer le contenu de ce qui se trouve dans le pointeur, dans la variable membre de la classe de telle sorte que même si je delete le pointeur après l'avoir passé à ma fonction, le contenu en mémoire ne sera pas delete car il aura été déplacé dans l'autre pointeur ?

Code cpp :

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

1
2
3
4
 
void Player::setAudioStream(SoundStream* stream) {
     this->stream = std::move(stream);
}

Ma classe SoundStream au fait est une classe de base donc, je ne peux pas appeler le constructeur sinon, ça va appeler le constructeur de la classe de base et non celui de la classe dérivée.

[Ehonn]

Bonjour

std::move sur un pointeur nu n'a pas vraiment de sens.
Dans ce cas, il devrait juste faire une copie du pointeur et l'ancien pointeur ne sera pas modifié.

Pour ton exemple, tu devrais utiliser std::unique_ptr comme ça tu identifies facilement qui a la responsabilité.
Avec std::unique_ptr, tu pourras faire ceci :

Code :

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

1
2
3
4
void Player::setAudioStream(std::unique_ptr<SoundStream> & stream)
{
     this->stream = std::move(stream);
}

[Invité]

Ok mais je ne sais toujours pas ce que fait std::move. :/

[Ehonn]

http://en.cppreference.com/w/cpp/utility/move

Grosso modo :
Sémantiquement, il déplace l'objet.
En pratique, il fait une copie de pointeur (si applicable) pour accélérer la copie. Il a le droit de faire ça car l'objet déplacé est invalide et ne doit pas être utilisé.

[jblecanard]

Hello

Juste pour être un petit peu plus précis : std::move déplace l'objet si c'est possible dans le contexte dans lequel il est appelé, sinon il est copié. Le déplacement d'un objet est implémenté par le constructeur par déplacement et l'opérateur d'affectation par déplacement. Il ne s'agit pas forcément d'une copie de pointeur ! Du reste, l'objet déplacé ne doit pas se retrouver dans un état invalide, bien qu'il soit modifé (une collection après déplacement sera vide, mais pas invalide).

std::move sur un pointeur va déplacer le pointeur et pas l'objet pointé. Ca ne sert à rien. Ca serait utile sur un unique_ptr comme suggéré par Ehonn.

[Médinoc]

En fait, move() lui-même ne déplace pas mais autorise le déplacement.
Ce que fait vraiment la fonction sous le capot, c'est transformer une référence non-const ordinaire (type &) en référence déplaçable (type &&), autorisant ainsi l'utilisation d'un constructeur de déplacement.

Ce constructeur déplacera le contenu de l'objet, l'exemple typique étant:

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class MonType : private noncopyable
{
public:
	...
	MonType(MonType &&src)
	{
		m_ptr = src.m_ptr;
		src.m_ptr = nullptr;
	}
	~MonType() { delete m_ptr; }
	...
private:
	int* m_ptr;
};

[Invité]

Ok je comprends déjà beaucoup mieux, merci.

Toute la documentation que j'ai trouvé là dessus jusqu'à présent je ne la comprenais pas très bien. :/

Je pensais que ça déplaçais l'objet pointé mais en fait non. :X

[Iradrille]

C'est très proche de std::swap au final ?

[koala01]

Salut,

C'est très proche de std::swap au final ?

Oui, d'une certaine manière, mais non...

swap va intervertir les données de deux objets en assurant qu'il n'y ait aucune perte de donnée, alors que move va "vampiriser" un objet pour en donner le contenu à l'autre.

Le résultat est que l'objet A se retrouve avec le contenu de l'objet B, que B se retrouve "vidé de sens" et que le contenu de A est "perdu" (ou, à tout le moins irrécupérable)

d'une certaine manière, move a un comportement qui correspond à la moitié de ce que fait swap

[JolyLoic]

Petit détail, mais important : Ce n'est pas move lui-même qui va vampiriser les données.

L'idée est qu'il existe deux versions d'une même fonction, une qui copie les données, et une qui les vampirise. Il y a des cas où la première version est naturellement appelée (le paramètre est un objet nommé) et d'autres où c'est la seconde (le paramètre n'est pas nommé, et donc ce n'est pas grave de le vampiriser, puisque personne d'autre n'y aura accès).

Il faut voir move comme une opération de cast, qui fait qu'on objet nommé sera considéré comme non nommé, et donc qui permettra la sélection de la seconde version de la fonction, qui elle pourra vampiriser.

Donc :
- Le code : std::move(o); ne fait rien !
- Le code : f(std::move(o)); où f prend en argument une référence constante sur un object ne va rien vampiriser du tout.
- Le code : f(o); où f existe en deux versions, une vampirisant et l'autre ne vampirisant pas, va choisir la version ne vampirisant pas (le paramètre est nommé : o).
- Le code : f(std::move(o)); où f existe en deux versions, une vampirisant et l'autre ne vampirisant pas, va choisir la version vampirisant.