Factories: how to pass temporary smart pointers to functions. C++

Question

I have a class Foo

class Foo; 

a factory returning a pointer to it:

std::unique_ptr<Foo> createFoo();  

and, since I have been told by Herb that a plain function with no special claim on the lifetime of Foo should take plain naked pointers:

void plainf(Foo* f); 

How is my client supposed to correctly do this?

plainF(createFoo()); 

He would not be happy if he had to write:

auto someName = createFoo(); plainF(someName.get());  

Answer 1

You can use the get member function which returns a raw pointer to the owned object.

plainF(createFoo().get()); 

---

The temporary created by createFoo() will not go out of scope until plainF has finished. So long as plainF doesn't pass the pointer up out of scope this is completely safe.

Answer 2

If you don't need the argument to plainF to be nullable, you can also change its signature to take the argument by reference, allowing for a slightly less verbose syntax:

std::unique_ptr<Foo> createFoo();  void plainf(Foo& f);  plainF(*createFoo()); 

All the lifetime considerations mentioned in NathanOliver's answer apply, so this is just as safe to use.

Note that this implies that createFoo will never return an empty unique_ptr. So if that function is allowed to fail, you must indicate that error through other means, eg. by throwing an exception.