QScopedPointer Class

Description détaillée

La gestion manuelle des objets alloués au tas est difficile et sujette aux erreurs, avec pour conséquence commune des fuites de mémoire et un code difficile à maintenir. QScopedPointer est une petite classe utilitaire qui simplifie grandement cette tâche en attribuant la propriété de la mémoire basée sur la pile aux allocations du tas, plus généralement appelées acquisition de ressources et initialisation (RAII).

QScopedPointer garantit que l'objet pointé sera supprimé lorsque la portée actuelle disparaîtra.

Considérons cette fonction qui effectue des allocations au tas et possède plusieurs points de sortie :

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;
}

Elle est encombrée par les appels manuels de suppression. Avec QScopedPointer, le code peut être simplifié :

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.data());
}

Le code généré par le compilateur pour QScopedPointer est le même que celui écrit manuellement. Le code qui utilise delete est candidat à l'utilisation de QScopedPointer (et si ce n'est pas le cas, éventuellement un autre type de pointeur intelligent tel que QSharedPointer). Le QScopedPointer n'a intentionnellement pas de constructeur de copie ou d'opérateur d'affectation, de sorte que la propriété et la durée de vie sont clairement communiquées.

La qualification const d'un pointeur C++ ordinaire peut également être exprimée avec un QScopedPointer :

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

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

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

Gestionnaires de nettoyage personnalisés

Les tableaux ainsi que les pointeurs qui ont été alloués à l'aide de malloc ne doivent pas être supprimés à l'aide de delete. Le deuxième paramètre de modèle de QScopedPointer peut être utilisé pour les gestionnaires de nettoyage personnalisés.

Les gestionnaires de nettoyage personnalisés suivants existent :

• QScopedPointerDeleter - la valeur par défaut, supprime le pointeur à l'aide de delete
• QScopedPointerArrayDeleter - supprime le pointeur en utilisant delete []. Utilisez ce gestionnaire pour les pointeurs alloués avec new [].
• QScopedPointerPodDeleter - supprime le pointeur en utilisant free(). Utilisez ce gestionnaire pour les pointeurs qui ont été alloués avec malloc().
• QScopedPointerDeleteLater - supprime un pointeur en appelant deleteLater(). Utilisez ce gestionnaire pour les pointeurs vers des QObject qui participent activement à une QEventLoop.

Vous pouvez passer vos propres classes en tant que gestionnaires, à condition qu'elles disposent d'une fonction statique publique 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);

Pointeurs déclarés à l'avance

Les classes déclarées en amont peuvent être utilisées dans QScopedPointer, à condition que le destructeur de la classe déclarée en amont soit disponible chaque fois qu'un QScopedPointer doit être nettoyé.

Concrètement, cela signifie que toutes les classes contenant un QScopedPointer qui pointe vers une classe déclarée en aval doivent avoir des constructeurs, des destructeurs et des opérateurs d'affectation non linéaires :

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 implicitly
                            // generate them.
};

Sinon, le compilateur émet un avertissement concernant l'impossibilité de déstructurer MyPrivateClass.