Should I use make_unique or reset() for already defined smart pointers?

Question

Suppose I have a function that optionally allocates an object and returns it:

// Class member
std::deque<Packet> m_receiveQueue;

// Function in class that operates on the queue
template<typename T>
std::unique_ptr<T> Get()
{
  std::unique_ptr<T> response;

  if (!m_receiveQueue.empty())
  {
     response = std::make_unique<T>(m_receiveQueue.front());
     m_receiveQueue.pop();
  }

  return response;
}

Should I instead do:

response.reset(new T{m_receiveQueue.front()});

Why or why not? Also does the same advice apply to other smart pointers, such as shared_ptr? Just looking for a best practice.

Answer 1

Don't do it, use the std::make_unique one.

If I were to look at your code, and see a call to reset, I might wonder what pointer the smart pointer was referring to before, and try to find the code where you change ownership of that pointer. But the smart pointer is empty in your case!

That's weird, why would you call reset on a empty pointer, it is already empty/"reset". Try to code so that your intent is better and clear, in this case, even though both are technically equivalent in your case, use std::make_unique. It better describes what you are trying to do (initializing a new smart pointer, not changing the ownership of it).