QScopedPointer Class

Descripción detallada

Gestionar manualmente los objetos asignados al heap es difícil y propenso a errores, con el resultado común de que el código pierde memoria y es difícil de mantener. QScopedPointer es una pequeña clase utilitaria que simplifica en gran medida esto asignando la propiedad de la memoria basada en la pila a las asignaciones de heap, más generalmente llamada adquisición de recursos es inicialización(RAII).

QScopedPointer garantiza que el objeto apuntado será borrado cuando el ámbito actual desaparezca.

Considera esta función que hace asignaciones de heap, y tiene varios puntos de salida:

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

Está gravada por las llamadas de borrado manual. Con QScopedPointer, el código puede simplificarse a:

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

El código que genera el compilador para QScopedPointer es el mismo que cuando se escribe manualmente. El código que hace uso de delete es candidato para el uso de QScopedPointer (y si no, posiblemente otro tipo de puntero inteligente como QSharedPointer). QScopedPointer intencionadamente no tiene constructor de copia ni operador de asignación, de forma que la propiedad y el tiempo de vida se comunican claramente.

La calificación const en un puntero C++ normal también puede expresarse con 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());

Manejadores de limpieza personalizados

Las matrices así como los punteros que han sido asignados con malloc no deben ser borrados usando delete. El segundo parámetro de plantilla de QScopedPointer puede utilizarse para gestores de limpieza personalizados.

Existen los siguientes gestores de limpieza personalizados:

• QScopedPointerDeleter - por defecto, borra el puntero usando delete
• QScopedPointerArrayDeleter - borra el puntero usando delete []. Utilice este manejador para punteros que fueron asignados con new [].
• QScopedPointerPodDeleter - borra el puntero utilizando free(). Utilice este controlador para los punteros que se asignaron con malloc().
• QScopedPointerDeleteLater - borra un puntero llamando a deleteLater() sobre él. Utilice este manejador para punteros a QObject's que están participando activamente en un QEventLoop.

Puedes pasar tus propias clases como manejadores, siempre que tengan una función estática pública 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);

Punteros declarados hacia delante

Las clases que se declaran hacia adelante se pueden utilizar dentro de QScopedPointer, siempre que el destructor de la clase declarada hacia adelante esté disponible siempre que un QScopedPointer necesite limpiarse.

Concretamente, esto significa que todas las clases que contengan un QScopedPointer que apunte a una clase declarada hacia adelante deben tener constructores, destructores y operadores de asignación no en línea:

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

De lo contrario, el compilador emite una advertencia acerca de no ser capaz de destruct MyPrivateClass.