Retourner un unique_ptr à partir de fonctions

Question

unique_ptr<T> ne permet pas la construction de copies, mais supporte la sémantique du déplacement. Pourtant, je peux retourner un unique_ptr<T> d'une fonction et affecte 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 se fait-il que la ligne 1 n'invoque pas le constructeur de copie et entraîne des erreurs de compilation ? Si je devais utiliser la ligne 2 au lieu de cela, il serait logique (en utilisant la ligne 2 fonctionne également, mais nous ne sommes pas tenus de le faire).

Je sais que C++0x permet cette exception pour unique_ptr puisque la valeur de retour est un objet temporaire qui sera détruit dès la sortie de la fonction, garantissant ainsi l'unicité du pointeur retourné. Je suis curieux de savoir comment cela est mis en œuvre, est-ce un cas spécial dans le compilateur ou y a-t-il une autre clause dans la spécification du langage que cela exploite ?

Answer 1

Je voudrais mentionner un cas où vous devez utiliser std::move(), sinon il donnera une erreur. Cas : Si le type de retour de la fonction diffère du type de la variable locale.

class Base { ... };
class Derived : public Base { ... };
...
std::unique_ptr<Base> Foo() {
     std::unique_ptr<Derived> derived(new Derived());
     return std::move(derived); //std::move() must
}

Référence : https://www.chromium.org/developers/smart-pointer-guidelines