c++ - ¿Cuál es la diferencia entre las clases QPointer, QSharedPointer y QWeakPointer en Qt?

pointers

Question

He leído de las documentaciones de Qt sobre las QPointer , QSharedPointer y QWeakPointer . Dice:

1. QPointer es una clase de plantilla que proporciona punteros guardados a los objetos Qt y se comporta como un puntero C ++ normal, excepto que se establece automáticamente en 0 cuando el objeto al que se hace referencia se destruye y no se producen "punteros colgantes".

2. QSharedPointer clase QSharedPointer contiene una referencia fuerte a un puntero compartido.

3. QWeakPointer clase QWeakPointer contiene una referencia débil a un puntero compartido.

Mi pregunta es "¿Cuál es la diferencia entre estas clases?". es decir, ¿cuál es la diferencia entre un puntero a un objeto y una referencia a un puntero? ¿Son todos indicadores de objetos con diferentes mecanismos y comportamientos?

Answer 1

QPointer:
QPointer solo puede señalar instancias de QObject . Se establecerá automáticamente en nullptr si el objeto apuntado se destruye. Es un puntero débil especializado para QObject .

Considera este fragmento:

QObject *obj = new QObject;
QPointer<QObject> pObj(obj);
delete obj;
Q_ASSERT(pObj.isNull()); // pObj will be nullptr now

QSharedPointer
Un puntero contado de referencia. El objeto real solo se eliminará cuando se destruyan todos los punteros compartidos. Equivalente a std::shared_ptr .

int *pI = new int;
QSharedPointer<int> pI1(pI);
QSharedPointer<int> pI2 = pI1;
pI1.clear();
// pI2 is still pointing to pI, so it is not deleted
pI2.clear();
// No shared pointers anymore, pI is deleted

Tenga en cuenta que mientras haya un puntero compartido, ¡el objeto no se borrará!

QWeakPointer:
Puede contener una referencia débil a un puntero compartido. No evitará que el objeto sea destruido, y simplemente se reiniciará. Equivalente a std::weak_ptr , donde lock es equivalente a toStrongRef .

int *pI = new int;
QSharedPointer<int> pI1(pI);
QWeakPointer<int> pI2 = pI1;
pI1.clear();
// No shared pointers anymore, pI is deleted
//
// To use the shared pointer, we must "lock" it for use:
QSharedPointer<int> pI2_locked = pI2.toStrongRef();
Q_ASSERT(pI2_locked.isNull());

Esto se puede usar si necesita acceder a un objeto controlado por otro módulo.

Para usar un puntero débil, debe convertirlo a un QSharedPointer . Nunca debe basar una decisión en que el puntero débil sea válido . Solo puede usar data() o isNull() para determinar que el puntero es nulo.

En general, para usar un puntero débil, debe convertirlo a un puntero compartido ya que dicha operación asegura que el objeto sobrevivirá mientras lo esté usando. Esto es equivalente a "bloquear" el objeto para acceder y es la única forma correcta de usar el objeto apuntado por un puntero débil.