QScopedPointer Class

Ausführliche Beschreibung

Die manuelle Verwaltung von Objekten, die im Heap zugewiesen wurden, ist schwierig und fehleranfällig, was häufig dazu führt, dass der Code Speicherlecks aufweist und schwer zu warten ist. QScopedPointer ist eine kleine Hilfsklasse, die diesen Vorgang erheblich vereinfacht, indem sie Heap-Zuweisungen eine stapelbasierte Speicherverantwortung zuweist – allgemein als „Resource Acquisition Is Initialization“ (RAII) bezeichnet. Der Template-Parameter „ T “ gibt den Typ des zu verwaltenden Zeigers an.

QScopedPointer garantiert, dass das Objekt, auf das gezeigt wird, gelöscht wird, sobald der aktuelle Geltungsbereich endet.

Betrachten Sie diese Funktion, die Heap-Zuweisungen durchführt und verschiedene Ausstiegspunkte 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 wird durch die manuellen `delete`-Aufrufe erschwert. Mit `QScopedPointer` lässt sich der Code wie folgt vereinfachen:

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

Der vom Compiler für `QScopedPointer` generierte Code entspricht dem manuell geschriebenen. Code, der ` delete ` verwendet, eignet sich für den Einsatz von `QScopedPointer` (und falls nicht, möglicherweise für einen anderen Typ eines intelligenten Zeigers wie ` QSharedPointer`). `QScopedPointer` verfügt absichtlich über keinen Kopierkonstruktor und keinen Zuweisungsoperator, damit Eigentumsverhältnisse und Lebensdauer klar kommuniziert werden.

Die „const“-Qualifikation bei einem regulären C++-Zeiger lässt sich auch mit einem `QScopedPointer` ausdrücken:

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

Benutzerdefinierte Cleanup-Handler

Arrays sowie Zeiger, die mit ` malloc ` zugewiesen wurden, dürfen nicht mit ` delete` gelöscht werden. Der Template-Parameter ` Cleanup ` gibt den Aufräumhandler an, der beim Zerstören des Bereichszeigers verwendet werden soll; standardmäßig wird `QScopedPointerDeleter` verwendet.

Es gibt die folgenden benutzerdefinierten Aufräumhandler:

• QScopedPointerDeleter – der Standardhandler, löscht den Zeiger mithilfe von delete
• QScopedPointerArrayDeleter – löscht den Zeiger mithilfe von delete []. Verwenden Sie diesen Handler für Zeiger, die mit new [] zugewiesen wurden.
• QScopedPointerPodDeleter – löscht den Zeiger mithilfe von ` free()`. Verwenden Sie diesen Handler für Zeiger, die mit ` malloc()` zugewiesen wurden.
• QScopedPointerDeleteLater – löscht einen Zeiger, indem „ deleteLater() “ darauf aufgerufen wird. Verwenden Sie diesen Handler für Zeiger auf „ QObject “, die aktiv an einem „ QEventLoop “ beteiligt sind.

Sie können eigene Klassen als Handler übergeben, sofern diese über eine öffentliche statische Funktion ` void cleanup(T *pointer)` verfügen.

// 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ärtsdeklarierte Zeiger

Vorwärtsdeklarierte Klassen können innerhalb von `QScopedPointer` verwendet werden, solange der Destruktor der vorwärtsdeklarierten 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 verweist, über nicht-inline-Konstruktoren, Destruktoren und Zuweisungsoperatoren verfügen 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 „ MyPrivateClass “ nicht zerstört werden kann.