c++ unique_ptr argument en passant

Je suis un peu surpris de voir que ce n'est pas une réponse très clairement et explicitement ici, ni sur n'importe quel endroit-je facilement tombé sur. Alors que je suis assez nouveau à ce genre de choses, je pense que le suivant peut être dit.

La situation est un appel de fonction qui construit un unique_ptr<T> valeur (éventuellement par le casting du résultat d'un appel à l' new), et veut passer à une fonction qui va prendre possession de l'objet pointé (en les stockant dans une structure de données par exemple, comme cela se passe ici dans une vector). Pour indiquer que la propriété a été obtenu par l'appelant, et il est prêt à le céder, le passage d'un unique_ptr<T> valeur est en place. Il ya aussi loin que je peux voir trois raisonnable modes de passage d'une telle valeur.

1. Passage par valeur, comme dans add(unique_ptr<B> b) dans la question.
2. En passant par des non-const lvalue de référence, comme dans add(unique_ptr<B>& b)
3. Passage par référence rvalue, comme dans add(unique_ptr<B>&& b)

En passant par const lvalue de référence ne serait pas raisonnable, car il ne permet pas la fonction appelée à prendre en main (et const référence rvalue serait encore plus idiot que je ne suis même pas sûr que c'est autorisé).

Autant que le code est valide va, les options 1 et 3 sont presque équivalents: ils la force de l'appelant d'écrire une rvalue comme argument à l'appel, éventuellement en l'enveloppant d'une variable dans un appel à std::move (si l'argument est déjà une rvalue, c'est à dire, sans nom, comme dans un casting de la suite de new, ce n'est pas nécessaire). Dans l'option 2 cependant, le passage d'une rvalue (éventuellement à partir d' std::move) est pas permis, et la fonction doit être appelée avec un nom unique_ptr<T> variable (lors du passage d'une fonte à partir de new, on doit attribuer à une variable en premier).

Quand std::move est en effet utilisée, la variable contenant le unique_ptr<T> valeur en l'appelant est conceptuellement déréférencé (converti en rvalue, respectivement en fonte de référence rvalue), et la propriété est donnée jusqu'à ce point. Dans l'option 1. le déréférencement est réel, et la valeur est déplacé à une temporaire qui est passé à la fonction appelée (si les rues de la fonction serait d'inspecter la variable en l'appelant, il trouverait-elle contenir un pointeur null déjà). La propriété a été transférée, et il n'y a aucun moyen de l'appelant pouvait décider de ne pas l'accepter (ne rien faire avec l'argument des causes de la pointe-de valeur pour être détruit à la sortie de la fonction; l'appel de la release méthode sur l'argument permettrait d'éviter cela, mais serait tout simplement suite à une fuite de mémoire). Étonnamment, les options 2. et 3. sont sémantiquement équivalent lors de l'appel de la fonction, bien qu'ils nécessitent une syntaxe différente pour l'appelant. Si la fonction appelée permettrait de passer l'argument à une autre fonction prenant une rvalue (comme le push_back méthode), std::move doit être inséré dans les deux cas, ce qui permettra de transférer la propriété à ce point. Si la fonction appelée oubliez pas de faire n'importe quoi avec l'argument, alors le visiteur se retrouve toujours propriétaires de l'objet, si la tenue d'un nom pour elle (comme c'est obligatoire dans l'option 2); cela en dépit du fait que dans le cas 3, depuis le prototype de fonction a demandé à l'appelant d'accord pour la libération de la propriété (soit en appelant std::move ou la fourniture d'une temporaire). En résumé, les méthodes ne

1. Forces de l'appelant à renoncer à la propriété, et être sûr de les revendiquer.
2. La Force de l'appelant à possèdent la propriété, et être préparé (par la fourniture d'une non const de référence) à l'abandonner; mais ce n'est pas explicite (pas d'appel de std::move nécessaire ou permis), ni de prendre de suite la propriété assurée. Je considère cette méthode plutôt floue, dans son intention, sauf s'il est expressément prévu que la prise de possession ou non est laissé à la discrétion de la fonction appelée (certains utilisent peut être imaginé, mais les appelants doivent être conscients)
3. Forces de l'appelant pour indiquer explicitement renoncer à la propriété, comme dans le 1. (mais le transfert de propriété est retardé jusqu'après le moment de l'appel de fonction).

L'Option 3 est assez clairement son intention; à condition que la propriété est en fait pris, c'est pour moi la meilleure solution. Il est légèrement plus efficace que 1 dans la mesure où aucun pointeur valeurs sont déplacés temporaires (les appels à std::move sont en fait des moulages et ne coûtent rien), ce qui peut être particulièrement pertinente si le pointeur est transmis à travers plusieurs intermédiaires fonctions avant que son contenu est en fait déplacé.

Voici un peu de code pour expérimenter avec.

class B
{
  unsigned long val;
public:
  B(const unsigned long& x) : val(x)
  { std::cout << "storing " << x << std::endl;}
  ~B() { std::cout << "dropping " << val << std::endl;}
};

typedef std::unique_ptr<B> B_ptr;

class A {
  std::vector<B_ptr> vb;
public:
  void add(B_ptr&& b)
  { vb.push_back(std::move(b)); } //or even better use emplace_back
};


void f() {
    A a;
    B_ptr b(new B(123)),c;
    a.add(std::move(b));
    std::cout << "---" <<std::endl;
    a.add(B_ptr(new B(4567))); //unnamed argument does not need std::move
}

Comme l'écrit, la production est

storing 123
---
storing 4567
dropping 123
dropping 4567

Note que les valeurs sont détruits dans la stockées dans le vecteur. Essayez de modifier le prototype de la méthode add (adaptation de tout autre code, si nécessaire, à faire de la compilation), et si oui ou non il passe sur son argument b. Plusieurs permutations de lignes de sortie peut être obtenue.

OriginalL'auteur Marc van Leeuwen

Votre code dans main pourrait être simplifié un peu, depuis le C++14:

a.add( make_unique<B>() );

où vous pouvez mettre des arguments pour B'constructeur à l'intérieur de l'intérieur des parenthèses.

Vous pourriez aussi envisager une fonction membre de classe qui prend possession d'un pointeur brut:

void take(B *ptr) { vb.emplace_back(ptr); }

et le code correspondant dans main serait:

a.take( new B() );

Une autre option est d'utiliser de transfert parfait pour l'ajout de vecteur de membres:

template<typename... Args>
void emplace(Args&&... args)
{ 
    vb.emplace_back( std::make_unique<B>(std::forward<Args>(args)...) );
}

et le code principal:

a.emplace();

où, comme avant, vous pourriez mettre des arguments du constructeur pour B à l'intérieur des parenthèses.

Lien vers exemple de travail

OriginalL'auteur M.M