Let us suposse I have a stack of "unused" dynamic objects. Each time I need a new object, I use one of this "unused" objects as placeholder for the new petition. Something like:

```
template<typename T>
class my_list
{
public:
   template<typename... Args>
   T* newObject(Args&&... args)
   {
       if (unused.empty())
          return new T(forward<Args>(args)...);
       else {
          auto* newbie = unused.top();
          unused.pop();

          newbie = new (newbie) T(forward<Args>(args)...); // l. X

          return newbie;
       }
   }

private:
   stack<T*> unused;

```

};

Question is, in line X, what is more efficient, the written sentence, or:

```
*newbie = std::move(T(forward<Args>(args)...));

```

That means, what is more time-efficient of both, a call of a `new` with `newbie` as address (avoiding petitions of new memory) or simply a movement of a new temporary object overwritting the original?