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