QExplicitlySharedDataPointer Class
template <typename T> class QExplicitlySharedDataPointerThe QExplicitlySharedDataPointer class represents a pointer to an explicitly shared object. More...
| Header: | #include <QExplicitlySharedDataPointer> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core)target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
Note: All functions in this class are reentrant.
Public Types
Public Functions
| QExplicitlySharedDataPointer() | |
| QExplicitlySharedDataPointer(T *data) | |
| QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<X> &o) | |
| QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T> &o) | |
| QExplicitlySharedDataPointer(QExplicitlySharedDataPointer<T> &&o) | |
| ~QExplicitlySharedDataPointer() | |
| const T * | constData() const |
| T * | data() const |
| void | detach() |
(since 6.0) T * | get() const |
(since 6.0) void | reset(T *ptr = nullptr) |
| void | swap(QExplicitlySharedDataPointer<T> &other) |
| T * | take() |
| bool | operator bool() const |
| bool | operator!() const |
| T & | operator*() const |
| T * | operator->() |
| T * | operator->() const |
| QExplicitlySharedDataPointer<T> & | operator=(QExplicitlySharedDataPointer<T> &&other) |
| QExplicitlySharedDataPointer<T> & | operator=(T *o) |
| QExplicitlySharedDataPointer<T> & | operator=(const QExplicitlySharedDataPointer<T> &o) |
Protected Functions
| T * | clone() |
Related Non-Members
| bool | operator!=(const QExplicitlySharedDataPointer<T> &lhs, const QExplicitlySharedDataPointer<T> &rhs) |
| bool | operator!=(const T *ptr, const QExplicitlySharedDataPointer<T> &rhs) |
| bool | operator==(const QExplicitlySharedDataPointer<T> &lhs, const QExplicitlySharedDataPointer<T> &rhs) |
| bool | operator==(const T *ptr, const QExplicitlySharedDataPointer<T> &rhs) |
Detailed Description
QExplicitlySharedDataPointer<T> makes writing your own explicitly shared classes easy. QExplicitlySharedDataPointer implements thread-safe reference counting, ensuring that adding QExplicitlySharedDataPointers to your reentrant classes won't make them non-reentrant.
Except for one big difference, QExplicitlySharedDataPointer is just like QSharedDataPointer. The big difference is that member functions of QExplicitlySharedDataPointer do not do the automatic copy on write operation (detach()) that non-const members of QSharedDataPointer do before allowing the shared data object to be modified. There is a detach() function available, but if you really want to detach(), you have to call it yourself. This means that QExplicitlySharedDataPointers behave like regular C++ pointers, except that by doing reference counting and not deleting the shared data object until the reference count is 0, they avoid the dangling pointer problem.
It is instructive to compare QExplicitlySharedDataPointer with QSharedDataPointer by way of an example. Consider the Employee example in QSharedDataPointer, modified to use explicit sharing as explained in the discussion Implicit vs Explicit Sharing.
Note that if you use this class but find you are calling detach() a lot, you probably should be using QSharedDataPointer instead.
In the member function documentation, d pointer always refers to the internal pointer to the shared data object.
See also QSharedData and QSharedDataPointer.
Member Type Documentation
QExplicitlySharedDataPointer::Type
This is the type of the shared data object. The d pointer points to an object of this type.
Member Function Documentation
[noexcept] QExplicitlySharedDataPointer::QExplicitlySharedDataPointer()
Constructs a QExplicitlySharedDataPointer initialized with nullptr as d pointer.
[explicit noexcept] QExplicitlySharedDataPointer::QExplicitlySharedDataPointer(T *data)
Constructs a QExplicitlySharedDataPointer with d pointer set to data and increments data's reference count.
[noexcept] template <typename X> QExplicitlySharedDataPointer::QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<X> &o)
This copy constructor is different in that it allows o to be a different type of explicitly shared data pointer but one that has a compatible shared data object.
By default, the d pointer of o (of type X *) gets implicitly converted to the type T *; the result of this conversion is set as the d pointer of this, and the reference count of the shared data object is incremented.
However, if the macro QT_ENABLE_QEXPLICITLYSHAREDDATAPOINTER_STATICCAST is defined before including the QExplicitlySharedDataPointer header, then the d pointer of o undergoes a static_cast to the type T *. The result of the cast is then set as the d pointer of this, and the reference count of the shared data object is incremented.
Warning: relying on such static_cast is potentially dangerous, because it allows code like this to compile:
QExplicitlySharedDataPointer<Base> base(new Base); QExplicitlySharedDataPointer<Derived> derived(base); // !!! DANGER !!!
Starting from Qt 5.4 the cast is disabled by default. It is possible to enable it back by defining the QT_ENABLE_QEXPLICITLYSHAREDDATAPOINTER_STATICCAST macro, and therefore to allow old code (that relied on this feature) to compile without modifications.
Note: Usage of the QT_ENABLE_QEXPLICITLYSHAREDDATAPOINTER_STATICCAST macro is deprecated. The macro will be removed in a future version of Qt.
[noexcept] QExplicitlySharedDataPointer::QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T> &o)
This standard copy constructor sets the d pointer of this to the d pointer in o and increments the reference count of the shared data object.
[noexcept] QExplicitlySharedDataPointer::QExplicitlySharedDataPointer(QExplicitlySharedDataPointer<T> &&o)
Move-constructs a QExplicitlySharedDataPointer instance, making it point at the same object that o was pointing to.
QExplicitlySharedDataPointer::~QExplicitlySharedDataPointer()
Decrements the reference count of the shared data object. If the reference count becomes 0, the shared data object is deleted. This is then destroyed.
[protected] T *QExplicitlySharedDataPointer::clone()
Creates and returns a deep copy of the current data. This function is called by detach() when the reference count is greater than 1 in order to create the new copy. This function uses the operator new and calls the copy constructor of the type T.
See QSharedDataPointer<T>::clone() for an explanation of how to use it.
[noexcept] const T *QExplicitlySharedDataPointer::constData() const
Returns a const pointer to the shared data object.
See also data().
[noexcept] T *QExplicitlySharedDataPointer::data() const
Returns a pointer to the shared data object.
void QExplicitlySharedDataPointer::detach()
If the shared data object's reference count is greater than 1, this function creates a deep copy of the shared data object and sets the d pointer of this to the copy.
Because QExplicitlySharedDataPointer does not do the automatic copy on write operations that members of QSharedDataPointer do, detach() is not called automatically anywhere in the member functions of this class. If you find that you are calling detach() everywhere in your code, consider using QSharedDataPointer instead.
[noexcept, since 6.0] T *QExplicitlySharedDataPointer::get() const
Same as data(). This function is provided for STL compatibility.
This function was introduced in Qt 6.0.
[noexcept, since 6.0] void QExplicitlySharedDataPointer::reset(T *ptr = nullptr)
Sets the d pointer of this to ptr and increments ptr's reference count if ptr is not nullptr. The reference count of the old shared data object is decremented, and the object deleted if the reference count reaches 0.
This function was introduced in Qt 6.0.
[noexcept] void QExplicitlySharedDataPointer::swap(QExplicitlySharedDataPointer<T> &other)
Swaps this explicitly-shared data pointer with other. This operation is very fast and never fails.
[noexcept] T *QExplicitlySharedDataPointer::take()
Returns a pointer to the shared object, and resets this to be nullptr. (That is, this function sets the d pointer of this to nullptr.)
Note: The reference count of the returned object will not be decremented. This function can be used together with the constructor that takes a QAdoptSharedDataTag tag object to transfer the shared data object without intervening atomic operations.
[noexcept] bool QExplicitlySharedDataPointer::operator bool() const
Returns true if the d pointer of this is not null.
[noexcept] bool QExplicitlySharedDataPointer::operator!() const
Returns true if the d pointer of this is nullptr.
T &QExplicitlySharedDataPointer::operator*() const
Provides access to the shared data object's members.
[noexcept] T *QExplicitlySharedDataPointer::operator->()
Provides access to the shared data object's members.
[noexcept] T *QExplicitlySharedDataPointer::operator->() const
Provides const access to the shared data object's members.
[noexcept] QExplicitlySharedDataPointer<T> &QExplicitlySharedDataPointer::operator=(QExplicitlySharedDataPointer<T> &&other)
Move-assigns other to this QExplicitlySharedDataPointer instance.
[noexcept] QExplicitlySharedDataPointer<T> &QExplicitlySharedDataPointer::operator=(T *o)
Sets the d pointer of this to o and increments o's reference count. The reference count of the old shared data object of this is decremented. If the reference count of the old shared data object becomes 0, the old shared data object is deleted.
[noexcept] QExplicitlySharedDataPointer<T> &QExplicitlySharedDataPointer::operator=(const QExplicitlySharedDataPointer<T> &o)
Sets the d pointer of this to the d pointer of o and increments the reference count of the shared data object. The reference count of the old shared data object of this is decremented. If the reference count of the old shared data object becomes 0, the old shared data object is deleted.
Related Non-Members
[noexcept] bool operator!=(const QExplicitlySharedDataPointer<T> &lhs, const QExplicitlySharedDataPointer<T> &rhs)
Returns true if lhs and rhs do not have the same d pointer.
[noexcept] bool operator!=(const T *ptr, const QExplicitlySharedDataPointer<T> &rhs)
Returns true if the d pointer of rhs is not ptr.
[noexcept] bool operator==(const QExplicitlySharedDataPointer<T> &lhs, const QExplicitlySharedDataPointer<T> &rhs)
Returns true if lhs and rhs have the same d pointer.
[noexcept] bool operator==(const T *ptr, const QExplicitlySharedDataPointer<T> &rhs)
Returns true if the d pointer of rhs is ptr.
© 2024 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.
