QScopedPointer Class

Description détaillée

La gestion manuelle des objets alloués sur le tas est difficile et source d'erreurs, ce qui se traduit souvent par des fuites de mémoire et un code difficile à maintenir. QScopedPointer est une petite classe utilitaire qui simplifie considérablement cette tâche en attribuant la propriété de la mémoire de la pile aux allocations du tas, ce que l'on appelle plus généralement « l'acquisition de ressources lors de l'initialisation » (RAII). Le paramètre de modèle T spécifie le type du pointeur géré.

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

Prenons l’exemple de cette fonction qui effectue des allocations sur le tas et comporte 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 alourdie par les appels manuels à `delete`. Avec `QScopedPointer`, le code peut être simplifié comme suit :

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 identique à celui écrit manuellement. Les codes utilisant delete sont des candidats à l’utilisation de QScopedPointer (et si ce n’est pas le cas, éventuellement un autre type de pointeur intelligent tel que QSharedPointer). QScopedPointer ne dispose intentionnellement ni de constructeur de copie ni d’opérateur d’affectation, afin que la propriété et la durée de vie soient clairement communiquées.

La qualification `const` sur un pointeur C++ classique 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 alloués à l’aide de ` malloc ` ne doivent pas être supprimés à l’aide de ` delete`. Le paramètre de modèle ` Cleanup ` spécifie le gestionnaire de nettoyage à utiliser lors de la destruction du pointeur à portée ; `QScopedPointerDeleter` est utilisé par défaut.

Les gestionnaires de nettoyage personnalisés suivants existent :

• QScopedPointerDeleter — par défaut, supprime le pointeur à l’aide de delete
• QScopedPointerArrayDeleter : supprime le pointeur à l’aide de delete []. Utilisez ce gestionnaire pour les pointeurs alloués avec new [].
• QScopedPointerPodDeleter : supprime le pointeur à l’aide de ` free()`. Utilisez ce gestionnaire pour les pointeurs alloués avec ` malloc()`.
• QScopedPointerDeleteLater - supprime un pointeur en appelant la fonction deleteLater() sur celui-ci. Utilisez ce gestionnaire pour les pointeurs vers des objets de type QObject qui participent activement à une instance de 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 avance peuvent être utilisées au sein d'un QScopedPointer, à condition que le destructeur de la classe déclarée en avance soit disponible chaque fois qu'un QScopedPointer doit effectuer un nettoyage.

Concrètement, cela signifie que toutes les classes contenant un QScopedPointer pointant vers une classe déclarée en avant doivent disposer de constructeurs, de destructeurs et d’opérateurs d’affectation non inline :

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 génère un avertissement indiquant qu'il est impossible de détruire MyPrivateClass.