Forcer le déplacement d'un objet incopiable

Version imprimable

Bonjour.

Je cherche à déplacer un objet incopiable dans un std::set pour que ce dernier en devienne le propriétaire, mais le code suivant provoque plusieurs erreur.
Apparemment le compilateur a du mal avec la fonction variadique et la substitution d'arguments.

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
#include <set>
 
struct Element {
	Element(int i = 0) : i(i) {};
	Element(Element const&) = delete;
	Element(Element&&) = default;
	int i;
};
 
bool operator < (const Element& Element1, const Element& Element2) {
	return Element1.i < Element2.i;
}
 
struct Container {
	std::set<Element> elems;
 
	void addElements() {}
 
	template<class ... Tail>
	void addElements(Element const&& elem, Tail&& ... tail) {
		elems.insert(elem);
		addElements(std::forward<Tail>(tail)...);
	}
};
 
int main(int, char**) {
	Container container;
	container.addElements(Element(9), Element(36));
 
	Element elem = 25;
	container.addElements(elem);
 
	return 0;
}

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
main.cpp: In function ‘int main(int, char**)’:
main.cpp:31:28: error: no matching function for call to ‘Container::addElements(Element&)’
  container.addElements(elem);
                            ^
main.cpp:31:28: note: candidates are:
main.cpp:17:7: note: void Container::addElements()
  void addElements() {}
       ^
main.cpp:17:7: note:   candidate expects 0 arguments, 1 provided
main.cpp:20:7: note: template<class ... Tail> void Container::addElements(const Element&&, Tail&& ...)
  void addElements(Element const&& elem, Tail&& ... tail) {
       ^
main.cpp:20:7: note:   template argument deduction/substitution failed:
main.cpp:31:28: note:   cannot convert ‘elem’ (type ‘Element’) to type ‘const Element&&’
  container.addElements(elem);
 
In file included from /**** blah blah ****/
main.cpp:21:20:   required from ‘void Container::addElements(const Element&&, Tail&& ...) [with Tail = {Element}]’
main.cpp:28:47:   required from here
/usr/include/c++/4.9/ext/new_allocator.h:120:4: error: use of deleted function ‘Element::Element(const Element&)’
  { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
    ^
main.cpp:5:2: note: declared here
  Element(Element const&) = delete;
  ^

Je voudrais savoir si il est possible de modifier Container pour qu'il déplace tout ce qui va dans addElements sans toucher au code client.
J'ai déjà tenté de surcharger addElements(Element const&) sans plus de résultats.

Cordialement.

Le code suivant compile chez moi :
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 #include <set> struct Element { Element(int i = 0) : i(i) {}; Element(Element const&) = delete; Element(Element&&) = default; Element &operator=(Element const &) = delete; Element &operator=(Element &&) = default; int i; }; bool operator < (const Element& Element1, const Element& Element2) { return Element1.i < Element2.i; } struct Container { std::set<Element> elems; void addElements() {} template<class ... Tail> void addElements(Element && elem, Tail&& ... tail) { elems.insert(std::move(elem)); addElements(std::forward<Tail>(tail)...); } }; int main(int, char**) { Container container; container.addElements(Element(9), Element(36)); Element elem = 25; container.addElements(std::move(elem)); return 0; }
Quatre modifs :
- Remplacer const && par &&
- Quand dans une fonction sink (prenant un argument par &&), on veut transmettre cet argument à une autre fonction, ne pas oublier que cet argument a désormais un nom, et qu'il faut utiliser std::move pour le rendre déplaçable void f(MonType &&var) { g(std::move(var));}- Dans ton main, pour l'appel à un argument, tu utilises un objet non temporaire, donc besoin d'appeler move.
- J'ai compléter ta classe avec les deux manquants de la règle des 5, parce que, même s'il n'interviennent pas ici, je n'ai pas envie d'avoir à raisonner avec des types trop tordus...

28/06/2015, 21h44
Daïmanu

Citation:

Envoyé par JolyLoic

- Dans ton main, pour l'appel à un argument, tu utilises un objet non temporaire, donc besoin d'appeler move.

J'aurais espéré ne pas avoir l'imposer au code client, mais puisqu'il le faut.

Citation:

Envoyé par JolyLoic

- J'ai compléter ta classe avec les deux manquants de la règle des 5, parce que, même s'il n'interviennent pas ici, je n'ai pas envie d'avoir à raisonner avec des types trop tordus...

Je n'avais simplement pas envie de surcharger l'exemple.

J'ai vraiment l'impression de patauger avec la move semantic :|, je peine à trouver de bon tutos dessus.

Merci en tous cas.

Cordialement.
29/06/2015, 09h36
ternel

Peut-être une fonction wrapper pourrait faire le std::move. Par exemple, une fonction comme std::set::emplace().
29/06/2015, 10h51
prgasp77

Puisque ton constructeur n'est pas explicit, l'instruction suivante est valide container.addElements(42); : crée la rvalue Element(42) et la déplace.
30/06/2015, 13h42
Arzar
Citation:

Envoyé par Daïmanu

J'aurais espéré ne pas avoir l'imposer au code client, mais puisqu'il le faut.

Pour info, ce fut une décision tout à fait volontaire par le comité d’empêcher ce genre de code de compiler :
Code:

1 2 3 Element elem = 25; container.addElements(elem); // move silencieux d'elem dans container
La move semantic a été conçu de manière à interdire tout déplacement silencieux. Si un client veut déplacer un objet dans le container il doit explicitement utiliser std::move.
30/06/2015, 14h10
Ehonn

Ou donner un temporaire comme l'a dit prgasp77

Code:

container.addElements(Element(25));