QExplicitlySharedDataPointer 类

template <typename T> class QExplicitlySharedDataPointer

The QExplicitlySharedDataPointer class represents a pointer to an explicitly shared object. 更多...

头: #include <QExplicitlySharedDataPointer>
qmake: QT += core
Since: Qt 4.4

该类在 Qt 4.4 引入。

注意: 此类的所有函数 可重入 .

公共类型

typedef Type

公共函数

QExplicitlySharedDataPointer (QExplicitlySharedDataPointer<T> && o )
QExplicitlySharedDataPointer (const QExplicitlySharedDataPointer<X> & o )
QExplicitlySharedDataPointer (const QExplicitlySharedDataPointer<T> & o )
QExplicitlySharedDataPointer (T * data )
QExplicitlySharedDataPointer ()
QExplicitlySharedDataPointer<T> & operator= (QExplicitlySharedDataPointer<T> && other )
QExplicitlySharedDataPointer<T> & operator= (const QExplicitlySharedDataPointer<T> & o )
~QExplicitlySharedDataPointer ()
const T * constData () const
T * data () const
void detach ()
void reset ()
void swap (QExplicitlySharedDataPointer<T> & other )
T * take ()
bool 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= (T * o )
bool operator== (const QExplicitlySharedDataPointer<T> & other ) const
bool operator== (const T * ptr ) const

保护函数

T * clone ()

详细描述

QExplicitlySharedDataPointer<T> makes writing your own explicitly shared classes easy. QExplicitlySharedDataPointer implements thread-safe reference counting, ensuring that adding QExplicitlySharedDataPointers to your 可重入 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 隐式 vs 明确共享 .

Note that if you use this class but find you are calling detach () a lot, you probably should be using QSharedDataPointer 代替。

In the member function documentation, d pointer always refers to the internal pointer to the shared data object.

另请参阅 QSharedData and QSharedDataPointer .

成员类型文档编制

typedef QExplicitlySharedDataPointer:: Type

这是共享数据对象的类型。 d pointer 指向此类型的对象。

成员函数文档编制

QExplicitlySharedDataPointer:: QExplicitlySharedDataPointer ( QExplicitlySharedDataPointer < T > && o )

Move-constructs a QExplicitlySharedDataPointer instance, making it point at the same object that o 所指向的。

该函数在 Qt 5.2 引入。

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.

默认情况下, 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.

警告: 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.

QExplicitlySharedDataPointer:: QExplicitlySharedDataPointer (const QExplicitlySharedDataPointer < T > & o )

This standard copy constructor sets the d pointer of this d pointer in o and increments the reference count of the shared data object.

QExplicitlySharedDataPointer:: QExplicitlySharedDataPointer ( T * data )

Constructs a QExplicitlySharedDataPointer with d pointer 设为 data 并递增 data 的引用计数。

QExplicitlySharedDataPointer:: QExplicitlySharedDataPointer ()

Constructs a QExplicitlySharedDataPointer initialized with nullptr as d pointer .

QExplicitlySharedDataPointer < T > &QExplicitlySharedDataPointer:: operator= ( QExplicitlySharedDataPointer < T > && other )

移动赋值 other 到此 QExplicitlySharedDataPointer 实例。

该函数在 Qt 5.2 引入。

QExplicitlySharedDataPointer < T > &QExplicitlySharedDataPointer:: operator= (const QExplicitlySharedDataPointer < T > & o )

设置 d pointer of this 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.

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.

QSharedDataPointer <T>::clone() for an explanation of how to use it.

该函数在 Qt 4.5 引入。

const T *QExplicitlySharedDataPointer:: constData () const

返回共享数据对象的 const 指针。

另请参阅 data ().

T *QExplicitlySharedDataPointer:: data () const

返回共享数据对象指针。

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.

因为 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 代替。

void QExplicitlySharedDataPointer:: reset ()

重置 this to be null - i.e., this function sets the d pointer of this to nullptr , but first it decrements the reference count of the shared data object and deletes the shared data object if the reference count became 0.

void QExplicitlySharedDataPointer:: swap ( QExplicitlySharedDataPointer < T > & other )

Swap this instance's explicitly shared data pointer with the explicitly shared data pointer in other .

T *QExplicitlySharedDataPointer:: take ()

Returns a pointer to the shared object, and resets this nullptr . (That is, this function sets the d pointer of this to nullptr )。

注意: The reference count of the returned object will not be decremented.

该函数在 Qt 5.12 引入。

bool QExplicitlySharedDataPointer:: operator bool () const

返回 true d pointer of this is not null.

bool QExplicitlySharedDataPointer:: operator! () const

返回 true d pointer of this is nullptr .

bool QExplicitlySharedDataPointer:: operator!= (const QExplicitlySharedDataPointer < T > & other ) const

返回 true if other and this do not 有相同 d pointer .

bool QExplicitlySharedDataPointer:: operator!= (const T * ptr ) const

返回 true d pointer of this is not ptr .

T &QExplicitlySharedDataPointer:: operator* () const

Provides access to the shared data object's members.

T *QExplicitlySharedDataPointer:: operator-> ()

Provides access to the shared data object's members.

T *QExplicitlySharedDataPointer:: operator-> () const

Provides const access to the shared data object's members.

QExplicitlySharedDataPointer < T > &QExplicitlySharedDataPointer:: operator= ( T * o )

设置 d pointer of this to o 并递增 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.

bool QExplicitlySharedDataPointer:: operator== (const QExplicitlySharedDataPointer < T > & other ) const

返回 true if other and this 有相同 d pointer .

bool QExplicitlySharedDataPointer:: operator== (const T * ptr ) const

返回 true d pointer of this is ptr .