Qu'est-ce qui arrive à unique_ptr après std :: move ()?

Ce code est ce que je veux faire:

Tony& Movie::addTony()
{
    Tony *newTony = new Tony;
    std::unique_ptr<Tony> tony(newTony);
    attachActor(std::move(tony));
    return *newTony;
}

Je me demandais si je pouvais faire ceci à la place:

Tony& Movie::addTony()
{
    std::unique_ptr<Tony> tony(new Tony);
    attachActor(std::move(tony));
    return *tony.get();
}

Mais *tony.get() être le même pointeur ou nulle? Je sais que je pourrais vérifier, mais qu'est-ce que le standard chose pour elle de le faire?

source d'informationauteur user3496846 | 2016-03-17

  1. 18

    Non, vous ne pouvez pas faire à la place. Le déplacement de la unique_ptr les valeurs null. Si elle n'a pas, alors il ne serait pas unique. Je suis bien sûr en supposant que attachActor ne pas faire quelque chose de stupide comme ceci:

    attachActor(std::unique_ptr<Tony>&&) {
    //take the unique_ptr by r-value reference,
    //and then don't move from it, leaving the
    //original intact
}

    Section 20.8.1 paragraphe 4.

    En outre, u (l'unique objet) peut, sur demande, transfert
    la propriété à un autre pointeur unique u2. Lors de la réalisation de ce
    transfert, à la suite de postconditions tenir:

       -- u2.p est égal à la pré-transfert de l'u.p,

       -- u.p est égal à nullptr, et

        - si le pré-transfert de l'u.d maintenu état, cet état a été transférée à u2.d.

  2. 7

    Que dit la norme (§ 20.8.1.2.1 ¶ 16, emphase ajoutée) que le constructeur de déplacement de std::unique_ptr

    unique_ptr(unique_ptr&& u) noexcept;

    Construit un unique_ptr par le transfert de la propriété de u à *this.

    Donc, après vous déplacez-construction de l'objet temporaire qui est passée en argument à attachActor forme de votre tonytony n'est plus propriétaire de l'objet et donc tony.get() == nullptr. (C'est l'un des rares cas où la bibliothèque standard de fait en fait des affirmations au sujet de l'état d'une déménagé loin de l'objet.)

    Cependant, le désir de retour à la référence peut être réalisé sans avoir recours à nu new premières et des pointeurs.

    Tony&
Movie::addTony()
{
  auto tony = std::make_unique<Tony>();
  auto p = tony.get();
  attachActor(std::move(tony));
  return *p;
}

    Ce code suppose que attachActor ne baissera pas son argument sur le sol. Sinon, le pointeur p serait dangle après attachActor a returned. Si cela ne peut pas être invoqué, vous devrez re-conception de votre interface et l'utilisation partagée des pointeurs au lieu.

    std::shared_ptr<Tony>
Movie::addTony()
{
  auto tony = std::make_shared<Tony>();
  attachActor(tony);
  return tony;
}