Qt::make_shared for creating QSharedPtr as std::make_shared for creating std::shared_ptr

Question

As stated in Bjarne Stroustrup's "A tour of C++", and as a known C++14 practice, one should avoid naked new and delete in the code. Standard library offers std::make_shared and std::make_unique for creating smart pointers to immediately store allocated objects in.

However, it is not possible to use these routines for non-standard smart pointers, like in Qt. Qt has its own memory management model (with parents), but also provides smart pointer classes like QSharedPointer and QPointer (though the latter is not actually an owning pointer).

My question is: isn't it convenient to create Qt analogs of std::make_shared? Like this, for creating QSharedPtr:

namespace Qt
{
  template<class T, class... Args>
  QSharedPointer<T> make_shared(Args&&... args)
  {
    return QSharedPointer<T>(new T(std::forward<Args>(args)...));
  }
}

Or like this, for creating QPointer:

namespace Qt
{
  template<class T, class... Args>
  QPointer<T> make_ptr(Args&&... args)
  {
     return QPointer<T>(new T(std::forward<Args>(args)...));
  }
}

And it can be used like:

auto pCancelButton = Qt::make_ptr<QPushButton>("Cancel", this);

Are there any caveats for this approach? Are there any publicly known usage of this approach?

UPDATE I claim that Qt::make_ptr is useful as long as QPointer is useful, because it will hide new operator and make sure new is called only for something that inherits QObject. Qt users do a lot of new's, but in this way we can be sure new is used only in Qt context. Any arguments on this thought?

Answer 1

Features such as make_shared strictly rely on the perfect forwarding feature, which is only available since C++11 and the introduction of universal (forwarding) references. Having said that, without a perfect forwarding, using this function may be inefficient. Qt is quite older than the recent C++ standard, hence it was not available till Qt 5.1 (just like previously you had to use Qt's internal pre-processing macros like SIGNAL and SLOT for making connections).

Qt 5.1 already provides its own implementation for making smart pointers for QSharedPointer.

That static create member function can be used as follows:

auto ptr = QSharedPointer<QPushButton>::create("Cancel", this);

But note the description:

Note: This function is only available with a C++11 compiler that supports perfect forwarding of an arbitrary number of arguments. If the compiler does not support the necessary C++11 features, you must use the overload that calls the default constructor.

There are two major advantages of using make_shared and create functions rather than directly calling constructor with allocating memory with new:

1. That special perfectly forwarding function can allocate in a single system call a memory for both stored object and reference counter.

2. The memory allocation is separated from the calling context, so you avoid memory leaks in case of an exception is thrown while constructing another object in e.g. a function call (where a compiler is free to choose the order in which arguments are evaluated). Consider:

   foo(QSharedPointer<QPushButton>(new QPushButton("Cancel", this)), MayThrow());
   

That is, if the compiler first executes the new QPushButton("Cancel", this) expression, and then calls the MayThrow() function before calling the constructor of QSharedPointer, you may leak memory if the MayThrow() function throws an exception.