unique_ptr, nécessite un move au return ?

Bonjour,

J'ai actuellement une fonction qui, une fois simplifiée, ressemble à ça :

Code:

---

1 2 3 4 5 6 7 8 9 10

#include <memory>   struct Base {};   struct Derived : Base {};   std::unique_ptr<Base> foo() { std::unique_ptr<Derived> ptr; return std::move(ptr); }

---

Ma question est : pourquoi le move est-il nécessaire ?

Pourquoi le code-suivant ne fonctionne-t-il pas ?

Code:

---

1 2 3 4 5 6 7 8 9 10

#include <memory>   struct Base {};   struct Derived : Base {};   std::unique_ptr<Base> foo() { std::unique_ptr<Derived> ptr; return ptr; }

---

En effet, il me semblait que le move était implicite au moment d'un return.

Où me trompe-je ?

Je vous remercie d'avance,
Equinoxe

Bonjour,

Le problème vient du fait que foo() retourne un unique_ptr<Base> alors que ptr est un unique_ptr<Derived>. Donc dans le return, le compilateur est obligé d'ajouter la construction d'un temporaire de type unique_ptr<Base> et donc d'appeler le constructeur d'unique_ptr prenant un const unique_ptr<T>& en paramètre, qui est explicitement déclaré =delete.

En fait on est dans le même cas que dans le code suivant :

Code:

---

1 2 3 4 5 6 7

std::unique_ptr<Base> foo() { std::unique_ptr<Derived> ptr(new Derived); //std::unique_ptr<Base> ptrbase(ptr); // erreur ici, ptr est une lvale value std::unique_ptr<Base> ptrbase(std::move(ptr)); // ok, std::move(ptr) est une rvalue return ptrbase; }

---

Ceci-dit je soupçonne très fortement que la véritable intention est de pouvoir utiliser le polymorphisme Base/Dérivé et dans ce cas l'utilisation correcte est en fait la suivante :

Code:

---

1 2 3 4 5 6

std::unique_ptr<Base> foo() { std::unique_ptr<Base> ptr(new Derived); //... return ptr; }

---

Si la fonction ne fait vraiment que ça (ou équivalent), l'écrire en une ligne permet au compilateur d'être sur que c'est un objet "temporaire" et va donc utiliser le move-constructor automatiquement à la place du constructeur par copie (si je ne me trompe pas, j'ai pas vérifié en compilant) :

Code:

---

1 2 3 4 5

std::unique_ptr<Base> foo() { return std::unique_ptr<Base> ptr(new Derived); }

---

Je ne comprends pas ta solution Klaim, si tu retournes un objet du bon type (un unique_ptr<Base>) comme dans ton code alors il n'y a pas du tout besoin de l'écrire en une ligne...

Citation:

---

Envoyé par Arzar

Bonjour,

Le problème vient du fait que foo() retourne un unique_ptr<Base> alors que ptr est un unique_ptr<Derived>. Donc dans le return, le compilateur est obligé d'ajouter la construction d'un temporaire de type unique_ptr<Base> et donc d'appeler le constructeur d'unique_ptr prenant un const unique_ptr<T>& en paramètre, qui est explicitement déclaré =delete.

En fait on est dans le même cas que dans le code suivant :

Code:

---

1 2 3 4 5 6 7

std::unique_ptr<Base> foo() { std::unique_ptr<Derived> ptr(new Derived); //std::unique_ptr<Base> ptrbase(ptr); // erreur ici, ptr est une lvale value std::unique_ptr<Base> ptrbase(std::move(ptr)); // ok, std::move(ptr) est une rvalue return ptrbase; }

---

Ceci-dit je soupçonne très fortement que la véritable intention est de pouvoir utiliser le polymorphisme Base/Dérivé et dans ce cas l'utilisation correcte est en fait la suivante :

Code:

---

1 2 3 4 5 6

std::unique_ptr<Base> foo() { std::unique_ptr<Base> ptr(new Derived); //... return ptr; }

---

---

Merci de l'explication !

Il me reste toutefois une question, pour éclaircir.
Etant donné que le return contiendrait donc un cast, comme return std::unique_ptr<Base>(ptr);, pourquoi le compilateur ne transforme-t-il pas ptr en xvalue, et donc n'appelle-t-il pas unique_ptr<T>(unique_ptr<U> &&) ?

Par ailleurs, c'est bien pour faire du polymorphisme. Mais le code entre la déclaration et le return dois faire appel à une fonction spécifique de Derived. Donc je ne peux pas utiliser un unique_ptr<Base>.

Citation:

---

Envoyé par Klaim

Si la fonction ne fait vraiment que ça (ou équivalent), l'écrire en une ligne permet au compilateur d'être sur que c'est un objet "temporaire" et va donc utiliser le move-constructor automatiquement à la place du constructeur par copie (si je ne me trompe pas, j'ai pas vérifié en compilant) :

Code:

---

1 2 3 4 5

std::unique_ptr<Base> foo() { return std::unique_ptr<Base> ptr(new Derived); }

---

---

Mon code est en fait plus complexe que ça, évidemment. ;)

La catégorie d'une expression ne change pas, ptr est une lvalue et restera une lvalue n'importe où dans ta fonction. Raison pour laquelle on utilise std::move(ptr) qui sera cette fois une xvalue (ptr reste une lvalue). Dans un return, le compilateur cast l'expression e à retourner vers le type de retour si son type n'est pas le bon, or le cast vers un class-type T n'est valide que si T f(e); est valide, ce qui n'est pas ton cas.

Merci !