Est-il correct de retourner la valeur null shared_ptr?

Par exemple, il y a une fonction qui trouve un objet et renvoie shared_ptr, si l'objet est trouvé, et doit indiquer en quelque sorte qu'aucun objet n'a été trouvé.

std::vector<std::shared_ptr> Storage::objects;

std::shared_ptr<Object> Storage::findObject()
{
  if (objects.find)
  {
    return objects[x];
  }
  else
  {
    return nullptr;
  }
}

std::shared_ptr<Object> obj = Storage::findObject();
if (obj)
{
  print("found");
}
else
{
  print("not found");
}

  1. Est-il correct de retour shared_ptr implicitement initialisé avec nullptr comme dans le haut-exemple? Il va travailler, mais il peut être fait de cette façon? Ou dois-je retourner shared_ptr par défaut construit à la place?

  2. Dans ce cas, il serait weak? Quelle est la bonne façon de vérifier que vide weak a été retourné? par weak::expiration de la fonction ou il existe d'autres moyens? Si la vérification par weak::expiré est la seule façon alors comment puis-je distinguer que la fonction renvoyée pointeur vide, ou l'objet a été supprimé simplement(multi-thread de l'environnement)?

Situation où l'objet n'est pas trouvé, est aussi courant de la situation, comme si l'objet est trouvé.
Si vous pouvez utiliser boost, optional<T> semble être exactement ce que vous voulez (ce qui semble être à venir dans le standard C++17). Si vous ne voulez pas les frais généraux, vous fondamentalement juste à montrer que nullptr est en fait une absence de valeur et non pas une erreur.
Non, il n'y a pas de différence.
De (cplusplus.com/reference/memory/shared_ptr ) - "Un shared_ptr qui n'est pas propriétaire du pointeur est appelé un vide shared_ptr. Un shared_ptr qui pointe vers aucun objet n'est appelé null shared_ptr et ne doit pas être déréférencés. Notez bien qu'un vide shared_ptr est pas nécessairement une valeur null shared_ptr, et null shared_ptr n'est pas nécessairement un vide shared_ptr."
C'est faux.

OriginalL'auteur John Lock | 2016-05-15

  1. 11

    Est-il correct de retour shared_ptr implicitement initialisé avec nullptr comme dans le haut-exemple?

    Oui, c'est correct pour initialiser shared_ptr avec nullptr. Il est également exact à attribuer nullptr à shared_ptr.

    Ou dois-je retourner shared_ptr par défaut construit à la place?

    Vous pouvez le faire de deux façons:

    1. retour shared_ptr initialisé avec nullptr

      return shared_ptr<Object>(nullptr);

    2. retour shared_ptr défaut de construction.

      return nullptr;

    Les deux façons sont correctes et que les deux ont le même effet. Vous pouvez utiliser n'importe quelle manière que vous voulez.

    Dans ce cas, il serait weak? Quelle est la bonne façon de vérifier que vide weak a été retourné? par weak::expiration de la fonction ou il existe d'autres moyens?

    weak_ptr devient nullptr (expire) chaque fois que le dernier shared_ptr associés avec l'objet est détruit.

    La bonne façon de travailler avec weak_ptr est de le convertir en shared_ptr avec verrouillage méthode, et ensuite de travailler avec créé shared_ptr. Dans ce cas, votre weak_ptr n'expire jusqu'à ce que vous avez que de nouvelles shared_ptr. Si vous ne vous convertissez pas weak_ptr en shared_ptr, votre weak_ptr peut expirer à tout moment.

    Et oui, avant de travailler avec les nouveaux shared_ptr, vous devez vérifier qu'elle n'est pas nulle, car weak_ptr peut avait expiré avant la création de shared_ptr avec lock méthode.

    std::weak_ptr<Object> Storage::findObject();

...

std::weak_ptr  <Object> weak   = Storage::findObject();
std::shared_ptr<Object> shared = weak.lock();
if (shared) //check that weak was not expired when we did "shared = weak.lock()"
{
    //do something with shared, it will not expire.
}

    OriginalL'auteur anton_rh