De retour unique_ptr de fonctions

unique_ptr<T> ne permet pas la copie de la construction, au lieu de cela il prend en charge la sémantique de déplacement. Pourtant, je peux retourner un unique_ptr<T> à partir d'une fonction et d'attribuer la valeur renvoyée à une variable.

#include <iostream>
#include <memory>

using namespace std;

unique_ptr<int> foo()
{
  unique_ptr<int> p( new int(10) );

  return p;                   //1
  //return move( p );         //2
}

int main()
{
  unique_ptr<int> p = foo();

  cout << *p << endl;
  return 0;
}

Le code ci-dessus compile et fonctionne comme prévu. Alors, comment est-ce que la ligne de 1 ne pas invoquer le constructeur de copie et entraîner des erreurs de compilation? Si je devais utiliser la ligne 2 au lieu de cela, il avait un sens (à l'aide de la ligne de 2 fonctionne aussi bien, mais nous ne sommes pas tenus de le faire).

Je sais C++0x permet à cette exception à unique_ptr depuis la valeur de retour est un objet temporaire qui sera détruit dès que la fonction se termine, ainsi, de garantir l'unicité de le pointeur retourné. Je suis curieux de savoir comment cela est mis en œuvre, est-il spécial enfermé dans le compilateur ou est-il un autre clause dans la spécification du langage que ce exploits?

Hypothétiquement, si vous étiez à la mise en œuvre d'une méthode de fabrique, préférez-vous 1 ou 2 pour le retour de l'usine de sortie? Je présume que ce serait l'utilisation la plus courante de 1 parce que, avec une bonne usine, vous voulez vraiment la propriété de l'construits chose à transmettre à l'appelant.
Ils ont tous deux de transmettre la propriété de la unique_ptr. Toute la question est de environ 1 et 2 sont deux façons différentes de réaliser la même chose.
dans ce cas, la RVO prend place dans c++0x ainsi, la destruction de l'unique objet sera une fois qui est effectuée après main fonction se termine , mais pas quand la foo sorties.

InformationsquelleAutor Praetorian | 2010-11-30

c++c++11 unique-ptr

198

est-il un autre clause dans la spécification du langage que ce exploits?

Oui, voir 12.8 §34 §35:

Lorsque certains critères sont respectés, une mise en œuvre est permis d'omettre de le copier/déplacer la construction d'un objet de classe [...]
Cette élision de copier/déplacer des opérations, appelées copie élision, est autorisé [...]
dans une instruction return dans une fonction avec une classe de type de retour, lorsque l'expression est le nom de
un non-volatile automatique des objets avec le même cv-non qualifiés de type que le type de retour de fonction [...]

Lorsque les critères d'élision d'une opération de copie sont remplies et que l'objet à copier est désigné par une lvalue,
résolution de surcharge pour sélectionner le constructeur de copie est exécutée pour la première fois comme si l'objet ont été désignés par une rvalue.

Voulais juste ajouter un point de plus que le retour par valeur devrait être le choix par défaut ici, car une valeur nommée dans l'instruction de retour dans le pire des cas, c'est à dire sans elisions en C++11 et C++14 et C++17 est traitée comme une rvalue. Ainsi, par exemple, la fonction suivante compile avec -fno-elide-constructors drapeau
```
std::unique_ptr<int> get_unique() {
  auto ptr = std::unique_ptr<int>{new int{2}}; //<- 1
  return ptr; //<- 2, moved into the to be returned unique_ptr
}

...

auto int_uptr = get_unique(); //<- 3
```
Avec le drapeau de la compilation il y a deux mouvements (1 et 2) qui se passe dans cette fonction, puis un déménagement plus tard (3).
- Ne vous signifie essentiellement que foo() est en effet également sur le point d'être détruite (si ce n'était pas affecté à quoi que ce soit), tout comme la valeur de retour de la fonction, et donc il est logique que le C++ utilise un constructeur de déplacement lorsque vous faites unique_ptr<int> p = foo();?
- Cette réponse indique une mise en œuvre est autorisé pour faire quelque chose... ça ne veut pas dire qu'il doit, donc, si c'était la seule pertinente de l'article, cela impliquerait en s'appuyant sur ce comportement n'est pas portable. Mais je ne pense pas que c'est vrai. Je suis enclin à penser que la réponse correcte a plus à voir avec le constructeur de déplacement, comme décrit dans Nikola Smiljanic et Bartosz Milewski de réponse.
- Il dit que c'est "autorisé" à effectuer des copier/déplacer élision dans ces cas, mais nous ne parlons pas de la copie élision ici. C'est la deuxième cité le paragraphe qui s'applique ici, qui piggy-back, sur la copie élision règles, mais n'est pas la copie élision lui-même. Il n'y a pas d'incertitude dans le deuxième alinéa, il est totalement portable.
- Je sais que c'est maintenant 2 ans plus tard, mais vous sentez-vous encore que c'est faux? Comme je l'ai mentionné dans le commentaire précédent, ce n'est pas sur la copie élision. Il se trouve que dans le cas où la copie élision pourrait s'appliquer (même si il ne peut pas s'appliquer avec std::unique_ptr), il existe une règle spéciale pour la première traiter les objets comme des rvalues. Je pense que c'est d'accord entièrement avec ce que Nikola a répondu.
- Non, je me trompe! J'ai mal lu la citation. J'ai mon étrangement jusqu'-voté commentaire 🙂
- vous avez raison. Retrait de mon downvote. [Oh ffs, mon vote est verrouillée et ne peut pas être modifié à moins que la réponse se trouve rejeté!?]
- Ne vous inquiétez pas, jusqu'à présent, je n'ai jamais vu quelqu'un mourir de 4 downvotes 😉
- Cette copie élision est connu comme RVO ou la Valeur de Retour Optiomization. Cette dernière existe, longtemps avant C++11. Voir en.wikipedia.org/wiki/Copy_elision#Return_value_optimization
- Alors, pourquoi faire j'ai toujours l'erreur "tentative de référence a supprimé la fonction" pour mon déménagement uniquement de type (supprimé constructeur de copie) lors du retour à exactement de la même manière que cet exemple?
- J'ai trouvé le problème, finalement, c'était causé par un membre de ne pas être mobile 😉
InformationsquelleAutor fredoverflow
93

Ce qui n'est nullement spécifique à std::unique_ptr, mais s'applique à toute la classe qui est mobile. Il est garanti par les règles de la langue, puisque vous êtes de retour par valeur. Le compilateur essaie d'éluder les copies, appelle un constructeur de déplacement si il ne peut pas supprimer les copies d'appeler un constructeur de copie si elle ne peut pas bouger, et ne parvient pas à compiler si il ne peut pas copier.

Si vous aviez une fonction qui accepte std::unique_ptr comme argument, vous ne serait pas en mesure de passer de p à elle. Vous devez appeler explicitement constructeur de déplacement, mais dans ce cas, vous ne devriez pas utiliser la variable p après l'appel à bar().
```
void bar(std::unique_ptr<int> p)
{
    //...
}

int main()
{
    unique_ptr<int> p = foo();
    bar(p); //error, can't implicitly invoke move constructor on lvalue
    bar(std::move(p)); //OK but don't use p afterwards
    return 0;
}
```
- eh bien, pas vraiment. Bien que p n'est pas temporaire, le résultat de foo(), ce qui est retourné, est; donc c'est une rvalue et peut être déplacé, ce qui rend l'attribution de main possible. Je dirais que vous avez été mal, sauf que Nikola semble alors appliquer cette règle à p lui-même qui EST dans l'erreur.
- Exactement ce que je voulais dire, mais je ne pouvais pas trouver les mots. J'ai enlevé qu'une partie de la réponse puisqu'il n'était pas très clair.
- J'ai une question: dans la question d'origine, il n'existe pas de différence substantielle entre la Ligne 1 et Ligne 2? A mon avis c'est le même depuis lors de la construction de p dans main, il se soucie uniquement de type de type de retour de foo, droit?
- Dans cet exemple, il n'y a absolument aucune différence, voir la citation de la norme dans l'acceptation de réponse.
- En fait, vous pouvez utiliser p par la suite, aussi longtemps que vous le lui attribuer. Jusque-là, vous ne pouvez pas essayer de référence le contenu.
- N'est pas le constructeur de copie pour std::unique_ptr enlevé pour être déplacer seule même RVO encore besoin d'elle?
InformationsquelleAutor Nikola Smiljanić
37

unique_ptr n'a pas le traditionnel constructeur de copie. Au lieu de cela il a un "constructeur de déplacement" qui utilise des références rvalue:
```
unique_ptr::unique_ptr(unique_ptr && src);
```
Référence rvalue (le double esperluette) ne se lient à une rvalue. C'est pourquoi vous obtenez une erreur lorsque vous essayez de passer une lvalue unique_ptr à une fonction. D'autre part, une valeur qui est renvoyée par une fonction est considérée comme une rvalue, de sorte que le constructeur de déplacement est appelé automatiquement.

Par la manière, ce sera le travail correctement:
```
bar(unique_ptr<int>(new int(44));
```
Temporaire unique_ptr ici est une rvalue.
- Je pense que le point est plus, pourquoi p - "évidemment" un lvalue - être traité comme un rvalue dans une instruction de retour return p; dans la définition de foo. Je ne pense pas qu'il n'y a aucun problème avec le fait que la valeur de retour de la fonction elle-même peut être "déplacé".
- N'emballage de la valeur retournée par la fonction std::move dire qu'il sera déplacé deux fois?
- std::move est juste une fantaisie de fonte à partir d'une lvalue de référence (&) de référence rvalue (&&). Étrangères de l'utilisation de std::move sur une référence rvalue aurez simplement à être un noop
InformationsquelleAutor Bartosz Milewski
9

Je pense que c'est parfaitement expliqué dans à l'article 25 de Scott Meyers Moderne Et Efficace De C++. En voici un extrait:

La partie de la Norme de la bénédiction de la RVO continue à dire que si les conditions de la RVO sont respectées, mais les compilateurs choisir de ne pas effectuer de copie élision, l'objet retourné doit être traitée comme une rvalue. En effet, la Norme exige que, lorsque le RVO est autorisée, copie élision ou std::move est implicitement appliqué aux objets locaux retourné.

Ici, RVO se réfère à valeur de retour d'optimisation, et si les conditions de la RVO sont remplies signifie retourner l'objet local a déclaré à l'intérieur de la fonction que vous attendez à faire de RVO, qui est aussi bien expliqué dans l'article 25 de son livre en se référant à la norme (ici le objet local comprend les objets temporaires créés par l'instruction return). Le plus important à prendre à partir de l'extrait est copier élision ou std::move est implicitement appliqué aux objets locaux retourné. Scott mentionne dans l'article 25, de ce qui std::move est implicitement appliqué lorsque le compilateur choisir de ne pas éluder la copie et le programmeur ne doit pas explicitement de le faire.

Dans votre cas, le code est clairement un candidat pour RVO car il renvoie l'objet local p et le type de p est le même que le type de retour, ce qui entraîne copie élision. Et si le compilateur choisit de ne pas éluder la copie, pour quelque raison que ce soit, std::move aurait botté en ligne 1.

InformationsquelleAutor David Lee
2

~~Une chose que je n'ai pas vu dans d'autres réponses,~~ Pour clarifier un autre réponses qu'il existe une différence entre le retour std::unique_ptr qui a été créé à l'intérieur d'une fonction, et celui qui a été donné à cette fonction.

L'exemple pourrait être comme ceci:
```
class Test
{int i;};
std::unique_ptr<Test> foo1()
{
    std::unique_ptr<Test> res(new Test);
    return res;
}
std::unique_ptr<Test> foo2(std::unique_ptr<Test>&& t)
{
    //return t;  //this will produce an error!
    return std::move(t);
}

//...
auto test1=foo1();
auto test2=foo2(std::unique_ptr<Test>(new Test));
```
- Il est mentionné dans la réponse par fredoverflow - clairement mis en évidence "automatique de l'objet". Une référence (y compris une référence rvalue) n'est pas automatiquement un objet.
- Ok, désolé. Je pense que mon code est juste une clarification ensuite.
InformationsquelleAutor v010dya

Vous devez vous connecter pour publier un commentaire.