在 C++ 11 中将 `nullptr` 作为 `std::shared_ptr` 返回是否安全？

Question

Taking the following code snippet as a starting example:

template <typename FOO>
std::shared_ptr<FOO> createSharedPtr(bool yesNo) {
  if (!yesNo) {
    return nullptr;
  } else {
    return make_shared<FOO>();
  }
}

I have thought the return nullptr; statement above is compliant with C++ 11 standard, as the nullptr will be used to construct a null std::shared_ptr when returning to caller, as described at cppreference shared_ptr :

constexpr shared_ptr( std::nullptr_t ) noexcept;            (2)

However, one of my colleagues keeps insisting that he should go for return shared_ptr<FOO>(); instead, as he cannot find any official documents nor examples that assigns nullptr to a std::shared_ptr .

Am I correct with my understanding? If yes, which document I should show him to prove my oppinion?

UPDATED 1

I actually did have a discussion with him, quoting the cppreference shared_ptr , and seems that his concern is now about:

That means that using shared_ptr() or shared_ptr(nullptr). But returning nullptr needs to do casting from nullptr to shared_ptr and it needs a copy constructor.

If I understand correctly, his concern is about how a nullptr gets constructed to become a shared_ptr . Regarding this, the key point is the implicit conversion from nullptr to shared_ptr . This should be equivalent to:

class A {
 public:
  A(int a) : a_(a) {}

 private:
  int a_;
};

A a = 1;

Which document should I look at to clarify the correctness of the above code?

UPDATED 2

Looks like Converting constructor can explain the key point here. Thank you all!

Answer 1

They mean the same thing. Here you can even see the generated assembly code is identical: https://godbolt.org/z/odKc4q9ja

If you prefer concision and/or dislike nullptr , you can return {} for the same effect.

Answer 2

Your colleague seems to confuse std::shared_ptr<Foo>(nullptr) with std::shared_ptr<FOO>(static_cast<FOO*>(nullptr)) . You are correct: the mentioned overload would be already guarantee that the returned shared_ptr does not hold a resource.

But even std::shared_ptr<FOO>(static_cast<FOO*>(nullptr)) is safe. From the standard, the preconditions for the ctor:

Preconditions: The expression delete[] p, when T is an array type, or delete p, when T is not an array type, has well-defined behavior, and does not throw exceptions.

delete static_cast<FOO*>(nullptr) meets both conditions: it doesn't do anything.