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?

make_with_parent would be better than make_ptr because the important thing is that the object's lifetime is managed by the parent. The specific type of non-owning pointer used to refer to the object is irrelevant. Forcing the use of QPointer would add unnecessary overhead in cases where a raw pointer would be sufficient. — Oktalist
– Oktalist, Commented Oct 10, 2014 at 15:14
In the case of QPointer it probably wouldn't make sense to combine the allocation of storage for the object and storage for the refcount in a single allocation of heap memory, because the refcount would be expected to outlive the object. — Oktalist
– Oktalist, Commented Oct 10, 2014 at 16:34

Michał Leon · Accepted Answer · 2024-02-25 11:30:50Z

20

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:

That special perfectly forwarding function can allocate in a single system call a memory for both stored object and reference counter.
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.

edited Feb 25, 2024 at 11:30

Michał Leon

2,3781 gold badge17 silver badges18 bronze badges

answered Oct 10, 2014 at 9:06

Piotr Skotnicki

48.8k7 gold badges122 silver badges167 bronze badges

Sign up to request clarification or add additional context in comments.

12 Comments

Mikhail Over a year ago

I actually know why make_shared is good, thanks, my question is not about that :) QSharedPointer::create is the essential part of your answer. Do you have any thoughts about this approach for QPointer?

Piotr Skotnicki Over a year ago

@Mikhail QPointer seems to be deprecated, just like STL's auto_ptr is (and I guess for the same reasons). QPointer is copyable so you can write your own implementation of make_qpointer, since it lacks that feature, but as a general rule you should avoid deprecated types. And for QScopedPointer I guess it lacks this feature since it is not copyable by definition and not moveable prior to C++11 (move was introduced in Qt5.2)

Mikhail Over a year ago

Are you sure that QPointer is deprecated? Please, check qt-project.org/forums/viewthread/27510

Piotr Skotnicki Over a year ago

@Mikhail it might have been undeprecated, but QPointer does not hold ownership of the object pointed to, so providing something like make_qpointer might not be useful for all cases at all

Oktalist Over a year ago

@Mikhail All memory leaks will be cleaned up when the program terminates. If you're prepared to rely on that then you don't need to care about smart pointers at all.

|

Collectives™ on Stack Overflow

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

1 Answer 1

12 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

12 Comments

Your Answer

Sign up or log in

Post as a guest

Related