C++ std::unique_ptr return from function and test for null

Question

I have a function that needs to return a pointer to an object of class myClass. For this purpose I´m using std::unique_ptr.

If the function succeeds, it shall return a pointer to a object with data. If it fails, it should return null.

This is my code skeleton:

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?
}

on 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
}

So here goes my questions:

a) Is that (returning an object or null) possible to be done using std::unique_ptr?

b) If possible, how to implement is?

c) If not possible, what are there alternatives?

Thanks for helping.

Creating a unique pointer as std::unique_ptr<T> myptr; doesn't allocate any memory, so you don't need to construct it and pass nullptr at all. So you can just create one and return it. — AndyG
– AndyG, Commented May 17, 2015 at 23:55
nullptr is a keyword new in C++11 for better support of null pointers. unique_ptr can be constructed from nullptr, even implicitly. — dyp
– dyp, Commented May 17, 2015 at 23:57
I see the != operator is being deprecated in C++20 for unique_ptr? en.cppreference.com/w/cpp/memory/unique_ptr — wcochran
– wcochran, Commented Mar 24, 2022 at 16:05
@wcochran the definition of the operator != has been removed in C++20, but thanks to the spaceship operator <=> you can still use the != on the type (and all other comparisons). — Stéphane Janel
– Stéphane Janel, Commented Jan 5, 2024 at 14:02
@wcochran With C++20 the compiler will rewrite a != b as !(a == b), details in this answer. — Brandlingo
– Brandlingo, Commented Sep 5, 2024 at 9:40

R Sahu · Accepted Answer · 2015-05-18 00:02:56Z

83

Either of the following should work:

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

To test whether the returned object points to a valid object or not, simply use:

if ( returnedData )
{
   // ...
}

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

edited May 18, 2015 at 0:02

answered May 17, 2015 at 23:59

R Sahu

207k15 gold badges168 silver badges291 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Mendes Over a year ago

Testing the result will be like if (returnedData != std::nullptr) ?

user118967 Over a year ago

@Mendes: yes. unique_ptr has a conversion to bool operator that indicates whether the unique pointer is empty or not.

Chris Drew · Accepted Answer · 2015-05-18 00:42:46Z

14

Yes, it is possible. A default constructed unique_ptr or one constructed from nullptr can be considered null:

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

To test for null either compare against nullptr or take advantage of conversion to bool:

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

    if (returnedData)
    {
        ... 
    }
}

answered May 18, 2015 at 0:42

Chris Drew

15.4k3 gold badges38 silver badges55 bronze badges

Comments

Barry · Accepted Answer · 2015-05-17 23:58:22Z

12

Yes it's possible. A default constructed unique_ptr is what you want:

Constructs a std::unique_ptr that owns nothing.

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

That is equivalent to the nullptr_t constructor, so perhaps this is more clear:

// No data found
return nullptr;

answered May 17, 2015 at 23:58

Barry

313k33 gold badges740 silver badges1.1k bronze badges

Comments

cardiff space man · Accepted Answer · 2015-12-03 23:01:44Z

-1

In the latest C++ library there should be a make_unique function in <memory> allowing us to make unique_ptr's as easily as in the C++11 library allows with make_shared and shared pointers.

So you could elucidate the code a little by returning std::make_unique(nullptr)

Plus in the next version of C++ there will be an "option" type which will evaluate as either a some value or a none value. The none value won't be allowed to be treated as if it was a valid value, unlike the empty unique_ptr could be treated like a nullptr. The option type will represent yet another piece of Boost entering the standard library.

answered Dec 3, 2015 at 23:01

cardiff space man

1,5361 gold badge16 silver badges34 bronze badges

4 Comments

underscore_d Over a year ago

Yup, boost::optional. Is there a document showing its acceptance into C++17? Edit: I guess this'll do: en.cppreference.com/w/cpp/utility/optional

cardiff space man Over a year ago

@underscore_d At this the N paper appears to be N4270, although the actual linked version of the paper seems rough (or "drafty" shall we say?)

underscore_d Over a year ago

Cool, thanks for the info! I hadn't heard about this being incorporated until now... or if I did hear, then I immediately forgot.

boycy Over a year ago

Your suggested code is wrong; std::make_unique requires a template argument specifying the object type to create, it forwards the function arguments to that object's constructor, and it never returns an empty pointer. Creating an empty pointer is just std::unique_ptr<myClass>{}; creating non-empty is std::make_unique<myClass>(myClassCtorArgs...)

Collectives™ on Stack Overflow

C++ std::unique_ptr return from function and test for null

4 Answers 4

2 Comments

Comments

Comments

4 Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

2 Comments

Comments

Comments

4 Comments

Linked

Related