Quelle est la différence entre les classes QPointer, QSharedPointer et QWeakPointer dans Qt?
j'ai lu dans les documentations Qt à propos de QPointer,QSharedPointer et QWeakPointer classes. Il dit:
QPointerest une classe de template qui fournit des pointeurs protégés vers les objets Qt et se comporte comme un pointeur c++ normal sauf qu'il est automatiquement mis à 0 lorsque l'objet référencé est détruit et qu'aucun "pointeur pendulaire" n'est produit.QSharedPointerla classe tient une forte référence à un pointeur.QWeakPointerclasse contient une faible référence à un pointeur partagé.
mes questions sont "Quelle est la différence entre ces classes?". j'.e quelle est la différence entre un pointeur vers un objet et une référence à un pointeur? Sont-ils tous des indicateurs d'objets avec des mécanismes et des comportements différents?
1 réponses
QPointer:QPointer ne peut point QObject instances. Il sera automatiquement réglé sur nullptr si le fait d'objet est détruit. C'est un pointeur faible spécialisé pour QObject.
Considérer ce fragment:
QObject *obj = new QObject;
QPointer<QObject> pObj(obj);
delete obj;
Q_ASSERT(pObj.isNull()); // pObj will be nullptr now
QSharedPointer
Une référence compté pointeur. L'objet sera supprimé seulement, lorsque tous les pointeurs partagés sont détruits. Équivalent à 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
Notez que tant qu'il y est un pointeur partagé, l'objet n'est pas supprimé!
QWeakPointer:
Peut contenir une référence faible à un pointeur partagé. Il n'empêchera pas l'objet d'être détruit, et est simplement réinitialisé. Équivalent à std::weak_ptr, où lock est équivalent à 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());
Cela peut être utilisé si vous avez besoin d'accéder à un objet qui est contrôlée par une autre module.
pour utiliser un pointeur faible, vous devez le convertir en QSharedPointer. Vous devez vous ne jamais fonder une décision sur la faiblesse du pointeur valide. Vous ne pouvez utiliser data() ou isNull() pour déterminer que le pointeur est null.
généralement, pour utiliser un pointeur faible, vous devez le convertir en pointeur partagé car une telle opération garantit que l'objet survivra aussi longtemps que vous l'utilisez. Cela équivaut à "verrouiller" l'objet pour l'accès et est la seule façon correcte d'utiliser l'objet pointé par un pointeur faible.