The QExplicitlySharedDataPointer class represents a pointer to an explicitly shared object. More...
#include <QExplicitlySharedDataPointer>Note: All functions in this class are reentrant.
This class was introduced in Qt 4.4.
| typedef | Type |
| QExplicitlySharedDataPointer () | |
| QExplicitlySharedDataPointer ( T * sharedData ) | |
| QExplicitlySharedDataPointer ( const QExplicitlySharedDataPointer<T> & other ) | |
| QExplicitlySharedDataPointer ( const QExplicitlySharedDataPointer<X> & other ) | |
| ~QExplicitlySharedDataPointer () | |
| const T * | constData () const |
| T * | data () const |
| void | detach () |
| void | reset () |
| void | swap ( QExplicitlySharedDataPointer & other ) |
| operator bool () const | |
| bool | operator! () const |
| bool | operator!= ( const QExplicitlySharedDataPointer<T> & other ) const |
| bool | operator!= ( const T * ptr ) const |
| T & | operator* () const |
| T * | operator-> () |
| T * | operator-> () const |
| QExplicitlySharedDataPointer<T> & | operator= ( const QExplicitlySharedDataPointer<T> & other ) |
| QExplicitlySharedDataPointer & | operator= ( T * sharedData ) |
| bool | operator== ( const QExplicitlySharedDataPointer<T> & other ) const |
| bool | operator== ( const T * ptr ) const |
| T * | clone () |
The QExplicitlySharedDataPointer class represents a pointer to an explicitly shared object.
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.
This is the type of the shared data object. The d pointer points to an object of this type.
Constructs a QExplicitlySharedDataPointer initialized with a null d pointer.
Constructs a QExplicitlySharedDataPointer with d pointer set to sharedData and increments sharedData's reference count.
This standard copy constructor sets the d pointer of this to the d pointer in other and increments the reference count of the shared data object.
This copy constructor is different in that it allows other to be a different type of explicitly shared data pointer but one that has a compatible shared data object. It performs a static cast of the d pointer in other and sets the d pointer of this to the converted d pointer. It increments the reference count of the shared data object.
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.
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::clone() for an explanation of how to use it.
This function was introduced in Qt 4.5.
Returns a const pointer to the shared data object.
See also data().
Returns a pointer to the shared data object.
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.
Resets this to be null. i.e., this function sets the d pointer of this to 0, but first it decrements the reference count of the shared data object and deletes the shared data object if the reference count became 0.
Swap this instance's explicitly shared data pointer with the explicitly shared data pointer in other.
Returns true if the d pointer of this is not null.
Returns true if the d pointer of this is null.
Returns true if other and this do not have the same d pointer.
Returns true if the d pointer of this is not ptr.
Provides access to the shared data object's members.
Provides access to the shared data object's members.
Provides const access to the shared data object's members.
Sets the d pointer of this to the d pointer of other 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.
Sets the d pointer of this to sharedData and increments sharedData'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.
Returns true if other and this have the same d pointer.
Returns true if the d pointer of this is ptr.