- Qt 5.15
- Qt Core
- C++ Classes
- QWeakPointer
- Qt 5.15.15 Reference Documentation

# Obsolete Members for QWeakPointer

The following members of class QWeakPointer are obsolete. They are provided to keep old source code working. We strongly advise against using them in new code.

## Public Functions

`(obsolete)` | QWeakPointer(const QObject *other)
`(obsolete)` T * | data() const
`(obsolete)` QWeakPointer<T> & | operator=(const QObject *other)

## Member Function Documentation

### QWeakPointer::QWeakPointer(const QObject *other)

This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.

Creates a QWeakPointer that holds a weak reference directly to the QObject other. This constructor is only available if the template type `T` is QObject or derives from it (otherwise a compilation error will result).

You can use this constructor with any QObject, even if they were not created with QSharedPointer.

Note that QWeakPointers created this way on arbitrary QObjects usually cannot be promoted to QSharedPointer.

This function was introduced in Qt 4.6.

See also QSharedPointer and QPointer.

### T *QWeakPointer::data() const

This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.

Use toStrongRef() instead, and data() on the returned QSharedPointer.

Returns the value of the pointer being tracked by this QWeakPointer, without ensuring that it cannot get deleted. To have that guarantee, use toStrongRef(), which returns a QSharedPointer object. If this function can determine that the pointer has already been deleted, it returns `nullptr`.

It is ok to obtain the value of the pointer and using that value itself, like for example in debugging statements:

         qDebug("Tracking %p", weakref.data());

However, dereferencing the pointer is only allowed if you can guarantee by external means that the pointer does not get deleted. For example, if you can be certain that no other thread can delete it, nor the functions that you may call.

If that is the case, then the following code is valid:

         // this pointer cannot be used in another thread
         // so other threads cannot delete it
         QWeakPointer<int> weakref = obtainReference();

         Object *obj = weakref.data();
         if (obj) {
             // if the pointer wasn't deleted yet, we know it can't get
             // deleted by our own code here nor the functions we call
             otherFunction(obj);
         }

Use this function with care.

This function was introduced in Qt 4.6.

See also isNull() and toStrongRef().

### QWeakPointer<T> &QWeakPointer::operator=(const QObject *other)

This function is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code.

Makes this QWeakPointer hold a weak reference directly to the QObject other. This function is only available if the template type `T` is QObject or derives from it.

This function was introduced in Qt 4.6.

See also QPointer.