QScopedPointer 類

template <typename T, typename Cleanup> class QScopedPointer

QScopedPointer 類存儲動態分配對象的指針，並在銷毀時刪除它。 更多...

頭：	#include <QScopedPointer>
qmake:	QT += core
Since:	Qt 4.6
繼承者：	QScopedArrayPointer

該類在 Qt 4.6 引入。

• 所有成員列錶，包括繼承成員

注意： 此類的所有函數 可重入 .

公共函數

	QScopedPointer (T * p = 0)
	~QScopedPointer ()
T *	data () const
T *	get () const
bool	isNull () const
void	reset (T * other = 0)
void	swap (QScopedPointer<T, Cleanup> & other )
T *	take ()
bool	operator bool () const
bool	operator! () const
T &	operator* () const
T *	operator-> () const

相關非成員

bool	operator!= (const QScopedPointer<T, Cleanup> & lhs , std::nullptr_t )
bool	operator!= ( std::nullptr_t , const QScopedPointer<T, Cleanup> & rhs )
bool	operator== (const QScopedPointer<T, Cleanup> & lhs , std::nullptr_t )
bool	operator== ( std::nullptr_t , const QScopedPointer<T, Cleanup> & rhs )

詳細描述

Managing heap allocated objects manually is hard and error prone, with the common result that code leaks memory and is hard to maintain. QScopedPointer is a small utility class that heavily simplifies this by assigning stack-based memory ownership to heap allocations, more generally called resource acquisition is initialization(RAII).

QScopedPointer guarantees that the object pointed to will get deleted when the current scope disappears.

Consider this function which does heap allocations, and has various exit points:

void myFunction(bool useSubClass)
{
    MyClass *p = useSubClass ? new MyClass() : new MySubClass;
    QIODevice *device = handsOverOwnership();
    if (m_value > 3) {
        delete p;
        delete device;
        return;
    }
    try {
        process(device);
    }
    catch (...) {
        delete p;
        delete device;
        throw;
    }
    delete p;
    delete device;
}
					

It's encumbered by the manual delete calls. With QScopedPointer, the code can be simplified to:

void myFunction(bool useSubClass)
{
    // assuming that MyClass has a virtual destructor
    QScopedPointer<MyClass> p(useSubClass ? new MyClass() : new MySubClass);
    QScopedPointer<QIODevice> device(handsOverOwnership());
    if (m_value > 3)
        return;
    process(device);
}
					

The code the compiler generates for QScopedPointer is the same as when writing it manually. Code that makes use of delete are candidates for QScopedPointer usage (and if not, possibly another type of smart pointer such as QSharedPointer ). QScopedPointer intentionally has no copy constructor or assignment operator, such that ownership and lifetime is clearly communicated.

The const qualification on a regular C++ pointer can also be expressed with a QScopedPointer:

    const QWidget *const p = new QWidget();
    // is equivalent to:
    const QScopedPointer<const QWidget> p(new QWidget());
    QWidget *const p = new QWidget();
    // is equivalent to:
    const QScopedPointer<QWidget> p(new QWidget());
    const QWidget *p = new QWidget();
    // is equivalent to:
    QScopedPointer<const QWidget> p(new QWidget());
					
					

自定義清理處理程序

Arrays as well as pointers that have been allocated with malloc must not be deleted using delete . QScopedPointer's second template parameter can be used for custom cleanup handlers.

The following custom cleanup handlers exist:

• QScopedPointerDeleter - the default, deletes the pointer using delete
• QScopedPointerArrayDeleter - deletes the pointer using delete [] . Use this handler for pointers that were allocated with new [] .
• QScopedPointerPodDeleter - deletes the pointer using free() . Use this handler for pointers that were allocated with malloc() .
• QScopedPointerDeleteLater - deletes a pointer by calling deleteLater() on it. Use this handler for pointers to QObject 's that are actively participating in a QEventLoop .

You can pass your own classes as handlers, provided that they have a public static function void cleanup(T *pointer) .

// this QScopedPointer deletes its data using the delete[] operator:
QScopedPointer<int, QScopedPointerArrayDeleter<int> > arrayPointer(new int[42]);
// this QScopedPointer frees its data using free():
QScopedPointer<int, QScopedPointerPodDeleter> podPointer(reinterpret_cast<int *>(malloc(42)));
// this struct calls "myCustomDeallocator" to delete the pointer
struct ScopedPointerCustomDeleter
{
    static inline void cleanup(MyCustomClass *pointer)
    {
        myCustomDeallocator(pointer);
    }
};
// QScopedPointer using a custom deleter:
QScopedPointer<MyCustomClass, ScopedPointerCustomDeleter> customPointer(new MyCustomClass);
					
					

轉發聲明指針

Classes that are forward declared can be used within QScopedPointer, as long as the destructor of the forward declared class is available whenever a QScopedPointer needs to clean up.

Concretely, this means that all classes containing a QScopedPointer that points to a forward declared class must have non-inline constructors, destructors and assignment operators:

class MyPrivateClass; // forward declare MyPrivateClass
class MyClass
{
private:
    QScopedPointer<MyPrivateClass> privatePtr; // QScopedPointer to forward declared class
public:
    MyClass(); // OK
    inline ~MyClass() {} // VIOLATION - Destructor must not be inline
private:
    Q_DISABLE_COPY(MyClass) // OK - copy constructor and assignment operators
                             // are now disabled, so the compiler won't implicitely
                             // generate them.
};
					

Otherwise, the compiler outputs a warning about not being able to destruct MyPrivateClass .

另請參閱 QSharedPointer .

成員函數文檔編製

QScopedPointer:: QScopedPointer ( T * p = 0)

Constructs this QScopedPointer instance and sets its pointer to p .

QScopedPointer:: ~QScopedPointer ()

銷毀此 QScopedPointer object. Delete the object its pointer points to.

T *QScopedPointer:: data () const

Returns the value of the pointer referenced by this object. QScopedPointer still owns the object pointed to.

T *QScopedPointer:: get () const

如同 data ().

該函數在 Qt 5.11 引入。

bool QScopedPointer:: isNull () const

返迴 true 若此對象引用 nullptr .

void QScopedPointer:: reset ( T * other = 0)

Deletes the existing object it is pointing to (if any), and sets its pointer to other . QScopedPointer now owns other and will delete it in its destructor.

To clear the pointer held without deleting the object it points to (and hence take ownership of the object), use take () 代替。

void QScopedPointer:: swap ( QScopedPointer < T , Cleanup > & other )

Swap this pointer with other .

T *QScopedPointer:: take ()

Returns the value of the pointer referenced by this object. The pointer of this QScopedPointer object will be reset to nullptr .

Callers of this function take ownership of the pointer.

bool QScopedPointer:: operator bool () const

返迴 true if the contained pointer is not nullptr . This function is suitable for use in if-constructs , like:

if (scopedPointer) {
    ...
}
					

另請參閱 isNull ().

bool QScopedPointer:: operator! () const

返迴 true 若此對象引用 nullptr .

另請參閱 isNull ().

T &QScopedPointer:: operator* () const

Provides access to the scoped pointer's object.

If the contained pointer is nullptr , behavior is undefined.

另請參閱 isNull ().

T *QScopedPointer:: operator-> () const

Provides access to the scoped pointer's object.

If the contained pointer is nullptr , behavior is undefined.

另請參閱 isNull ().

相關非成員

template <typename T, typename Cleanup> bool operator!= (const QScopedPointer < T , Cleanup > & lhs , std::nullptr_t )

返迴 true if lhs refers to a valid (i.e. non-null) pointer.

該函數在 Qt 5.8 引入。

另請參閱 QScopedPointer::isNull ().

template <typename T, typename Cleanup> bool operator!= ( std::nullptr_t , const QScopedPointer < T , Cleanup > & rhs )

返迴 true if rhs refers to a valid (i.e. non-null) pointer.

該函數在 Qt 5.8 引入。

另請參閱 QScopedPointer::isNull ().

template <typename T, typename Cleanup> bool operator== (const QScopedPointer < T , Cleanup > & lhs , std::nullptr_t )

返迴 true if lhs refers to nullptr .

該函數在 Qt 5.8 引入。

另請參閱 QScopedPointer::isNull ().

template <typename T, typename Cleanup> bool operator== ( std::nullptr_t , const QScopedPointer < T , Cleanup > & rhs )

返迴 true if rhs refers to nullptr .

該函數在 Qt 5.8 引入。

另請參閱 QScopedPointer::isNull ().

內容

1. 公共函數

2. 相關非成員

3. 詳細描述

4. 自定義清理處理程序

5. 轉發聲明指針