C ++ std :: unique_ptr retourne de la fonction et teste null

J'ai une fonction qui doit retourner un pointeur vers un objet de la classe myClass. Pour cela jutilise std::unique_ptr.

Si la fonction réussit, il doit retourner un pointeur vers un objet avec les données. Si il échoue, il doit retourner null.

C'est mon code skelepton:

std::unique_ptr<myClass> getData()
{
   if (dataExists)
      ... create a new myClass object, populate and return it ...

   //No data found
   return std::unique_ptr<myClass> (null); <--- Possible ?
}

sur main:

main()
{
   std::unique_ptr<myClass> returnedData;

   returnedData = getData();

   if (returnedData != null)   <-- How to test for null ?
   {
      cout << "No data returned." << endl;
      return 0;
   }

   //Process data
}

Donc voilà mes questions:

un) Est que (de retour d'un objet ou d' null) possible, pour être fait à l'aide de std::unique_ptr ?

b) Si possible, comment mettre en œuvre ?

c) Si pas possible, quelles sont les alternatives ?

Merci pour votre aide.

source d'informationauteur Mendes | 2015-05-17

  1. 23

    De la façon suivante devrait fonctionner:

    return std::unique_ptr<myClass>{};
return std::unique_ptr<myClass>(nullptr);

    Pour tester si l'objet retourné points d'un objet valide ou non, il suffit d'utiliser:

    if ( returnedData )
{
   //...
}

    Voir http://en.cppreference.com/w/cpp/memory/unique_ptr/operator_bool.

  2. 6

    Oui c'est possible. Un défaut construit unique_ptr est ce que vous voulez:

    Construit un std::unique_ptr qui est propriétaire de rien. 

    //No data found
return std::unique_ptr<myClass>{};

    Qui est l'équivalent de la nullptr_t constructeur, donc c'est peut-être plus clair:

    //No data found
return nullptr;
  3. 3

    Oui, c'est possible. Un défaut construit unique_ptr ou l'on construit à partir de nullptr peut être considérée comme nulle:

    std::unique_ptr<MyClass> getData()
{
    if (dataExists)
        return std::make_unique<MyClass>();
    return nullptr;
}

    De tester la valeur null comparez soit contre nullptr ou de prendre avantage de la conversion en booléen:

    int main()
{
    std::unique_ptr<MyClass> returnedData = getData();

    if (returnedData)
    {
        ... 
    }
}
  4. 2

    Oui, c'est possible.

    À partir de la page de référence std::unique_ptr::unique_ptr():

    constexpr unique_ptr();

    Construit un std::unique_ptr qui est propriétaire de rien.

    Donc, en gros:

    std::unique_prt<myClass> getData()
{
   myClass* data_ptr = nullptr;

   if (dataExists)
      //Create a new myClass object, populate and store in 'data_ptr'

   return std::unique_ptr<myClass>(data_ptr); //'data_ptr' is either valid pointer or nullptr
}

    De nullité vérifier, utiliser std::unique_ptr::opérateur booléen - il suffit de l'utiliser comme condition à l'intérieur de if déclaration:

    main()
{
   std::unique_ptr<myClass> returnedData = getData();

   if (returnedData)
   {
       //Data OK - Process
   }

}

    Comme page de référence pour std::unique_ptr::opérateur booléen dit:

    Vérifie si *this possède un objet, c'est à dire si get() != nullptr.

  5. 1

    Dans la plus récente de la bibliothèque C++ il devrait y avoir un make_unique fonction dans <memory> nous permet de faire unique_ptr's aussi facilement que dans le C++11 de la bibliothèque permet avec make_shared et partagé des pointeurs.

    De sorte que vous pourrait permettre d'élucider le code un peu en retournant std::make_unique(nullptr)

    Plus dans la prochaine version de C++, il y aura une "option" type qui permettra d'évaluer comme un some valeur ou un none valeur. Le none valeur ne pourra pas être traitée comme si elle était une valeur valide, contrairement au vide unique_ptr pourrait être traité comme un nullptr. L'option de type représentera encore un autre morceau de Boost entrer dans la bibliothèque standard.