Quelle est la différence entre QPointer, QSharedPointer et QWeakPointer classes de Qt?

QPointer:

QPointer ne peut pointer que vers QObject instances. Il sera automatiquement mis à nullptr si le fait d'objet est détruit. C'est un faible pointeur 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

Noter que tant qu'il y est un pointeur partagé, l'objet n'est pas supprimé!

QWeakPointer:

Peut contenir une faible référence à un pointeur partagé. Il n'empêchera pas l'objet de la destruction, et qui est tout simplement réinitialiser. É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());

Ceci peut être utilisé si vous avez besoin d'accéder à un objet qui est contrôlé par un autre module.

D'utiliser un faible pointeur, vous devez le convertir en un QSharedPointer. Vous devriez 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, l'utilisation d'un faible pointeur, vous devez le convertir en un pointeur partagé car une telle opération permet de s'assurer que l'objet va survivre aussi longtemps que vous l'utilisez. C'est l'équivalent de "verrouillage" de l'objet pour l'accès et la seule façon correcte de l'utilisation de l'objet pointé par un faible pointeur.

QScopedPointer:

C'est juste une classe helper qui permet de supprimer l'objet référencé lorsque le pointeur est hors de portée. Ainsi, lie un objet alloué dynamiquement à une portée variable.

Vous pouvez l'utiliser pour RAII sémantique pour les habitants, par exemple:

MyClass *foo() {
    QScopedPointer<MyClass> myItem(new MyClass);
    //Some logic
    if (some condition) {
        return nullptr; //myItem will be deleted here
    }
    return myItem.take(); //Release item from scoped pointer and return it
}

L'élément seront également supprimés dans le cas d'une exception

Un autre cas d'utilisation peuvent être variables membres d'un objet. Ensuite, vous n'avez pas besoin d'écrire un destructeur pour ceux:

class MyClass {
public:
    MyClass() : myPtr(new int) {}
private:
    QScopedPointer<int> myPtr; //Will be deleted automatically when containing object is deleted
}