QScopedPointer Class

Detaillierte Beschreibung

Die manuelle Verwaltung von Objekten, die dem Heap zugewiesen wurden, ist schwierig und fehleranfällig, mit dem üblichen Ergebnis, dass der Code Speicherverluste aufweist und schwer zu warten ist. QScopedPointer ist eine kleine Dienstleistungsklasse, die dies stark vereinfacht, indem sie Heap-Allokationen stapelbasierten Speicherbesitz zuweist, was allgemein als Resource Acquisition is Initialization (RAII) bezeichnet wird.

QScopedPointer garantiert, dass das Objekt, auf das gezeigt wird, gelöscht wird, wenn der aktuelle Bereich verschwindet.

Betrachten Sie diese Funktion, die Heap-Allokationen durchführt und verschiedene Exit-Points hat:

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

Sie ist durch die manuellen Löschaufrufe belastet. Mit QScopedPointer kann der Code vereinfacht werden:

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

Der Code, den der Compiler für QScopedPointer erzeugt, ist derselbe wie beim manuellen Schreiben. Code, der delete verwendet, ist ein Kandidat für die Verwendung von QScopedPointer (und falls nicht, möglicherweise ein anderer Typ von Smart Pointer wie QSharedPointer). QScopedPointer hat absichtlich keinen Kopierkonstruktor oder Zuweisungsoperator, so dass Eigentum und Lebensdauer klar kommuniziert werden.

Die const-Qualifikation eines normalen C++-Zeigers kann auch mit einem QScopedPointer ausgedrückt werden:

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

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

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

Benutzerdefinierte Bereinigungshandler

Sowohl Arrays als auch Zeiger, die mit malloc alloziert wurden, dürfen nicht mit delete gelöscht werden. Der zweite Template-Parameter von QScopedPointer kann für benutzerdefinierte Cleanup-Handler verwendet werden.

Die folgenden benutzerdefinierten Cleanup-Handler existieren:

• QScopedPointerDeleter - der Standard, löscht den Zeiger mit delete
• QScopedPointerArrayDeleter - löscht den Zeiger mit delete []. Verwenden Sie diesen Handler für Zeiger, die mit new [] zugewiesen wurden.
• QScopedPointerPodDeleter - löscht den Zeiger unter Verwendung von free(). Verwenden Sie diesen Handler für Zeiger, die mit malloc() zugewiesen wurden.
• QScopedPointerDeleteLater - löscht einen Zeiger, indem er deleteLater() aufruft. Verwenden Sie diesen Handler für Zeiger auf QObject's, die aktiv an einem QEventLoop beteiligt sind.

Sie können Ihre eigenen Klassen als Handler übergeben, vorausgesetzt, sie haben eine öffentliche statische Funktion 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);

Vorwärts deklarierte Zeiger

Klassen, die vorwärts deklariert sind, können innerhalb von QScopedPointer verwendet werden, solange der Destruktor der vorwärts deklarierten Klasse verfügbar ist, wenn ein QScopedPointer aufgeräumt werden muss.

Konkret bedeutet dies, dass alle Klassen, die einen QScopedPointer enthalten, der auf eine vorwärts deklarierte Klasse zeigt, nicht-inline Konstruktoren, Destruktoren und Zuweisungsoperatoren haben müssen:

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

Andernfalls gibt der Compiler eine Warnung aus, dass er nicht in der Lage ist, MyPrivateClass zu destruieren.