Discussion :

[Ekleog]

Bonjour,

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

Code :

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

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 :

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

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

[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 :

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

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 :

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

1
2
3
4
5
6
std::unique_ptr<Base> foo() 
{
    std::unique_ptr<Base> ptr(new Derived);
    //...
    return ptr;
}

[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 :

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

1
2
3
4
5
 
std::unique_ptr<Base> foo() 
{
    return std::unique_ptr<Base> ptr(new Derived);
}

[Arzar]

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...

[Ekleog]

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 :

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

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 :

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

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>.

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 :

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

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.

[Flob90]

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.

[Ekleog]

Merci !