En esta página

QScopedPointer Class

template <typename T, typename Cleanup> class QScopedPointer

La clase `QScopedPointer` almacena un puntero a un objeto asignado dinámicamente y lo elimina al destruirse. Más información...

Cabecera: #include <QScopedPointer>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Heredado por:

QScopedArrayPointer

Nota: Todas las funciones de esta clase son reentrantes.

Funciones públicas

QScopedPointer(T *p = nullptr)
~QScopedPointer()
T *data() const
T *get() const
bool isNull() const
void reset(T *other = nullptr)
operator bool() const
bool operator!() const
T &operator*() const
T *operator->() const
bool operator!=(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
bool operator!=(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t)
bool operator!=(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs)
bool operator==(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
bool operator==(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t)
bool operator==(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs)

Descripción detallada

La gestión manual de objetos asignados en el montón es complicada y propensa a errores, lo que suele provocar fugas de memoria en el código y dificulta su mantenimiento. QScopedPointer es una pequeña clase de utilidad que simplifica enormemente este proceso al asignar la propiedad de la memoria basada en la pila a las asignaciones del montón, lo que se conoce más generalmente como «adquisición de recursos en la inicialización» (RAII). El parámetro de plantilla T especifica el tipo del puntero que se está gestionando.

QScopedPointer garantiza que el objeto al que apunta se eliminará cuando desaparezca el ámbito actual.

Consideremos esta función que realiza asignaciones en el montón 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;
}

Se ve lastrada por las llamadas manuales a `delete`. Con `QScopedPointer`, el código se puede simplificar 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 si se escribiera manualmente. El código que utiliza delete es candidato para el uso de QScopedPointer (y, si no es así, posiblemente otro tipo de puntero inteligente, como QSharedPointer). QScopedPointer carece intencionadamente de constructor de copia y de operador de asignación, de modo que la propiedad y el ciclo de vida quedan claramente definidos.

La calificación «const» en un puntero normal de C++ 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

Ni los arrays ni los punteros que se hayan asignado con ` malloc ` deben eliminarse utilizando ` delete`. El parámetro de plantilla ` Cleanup ` especifica el controlador de limpieza que se debe utilizar cuando se destruye el puntero con ámbito; por defecto se utiliza `QScopedPointerDeleter`.

Existen los siguientes manejadores de limpieza personalizados:

  • QScopedPointerDeleter: el predeterminado; elimina el puntero mediante delete
  • QScopedPointerArrayDeleter: elimina el puntero mediante ` delete []`. Utilice este controlador para punteros que se hayan asignado con ` new []`.
  • QScopedPointerPodDeleter: elimina el puntero mediante ` free()`. Utilice este controlador para los punteros que se hayan asignado con ` malloc()`.
  • QScopedPointerDeleteLater: elimina un puntero llamando a deleteLater() sobre él. Utiliza este controlador para punteros a objetos creados con QObject que participan activamente en un QEventLoop.

Puedes pasar tus propias clases como controladores, siempre que dispongan de una función pública y estática ` 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 por adelantado

Las clases declaradas por adelantado pueden utilizarse dentro de QScopedPointer, siempre y cuando el destructor de la clase declarada por adelantado esté disponible cuando un QScopedPointer necesite realizar la limpieza.

En concreto, esto significa que todas las clases que contengan un `QScopedPointer` que apunte a una clase declarada por adelantado deben tener constructores, destructores y operadores de asignación no 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.
};

De lo contrario, el compilador emite una advertencia indicando que no se puede destruir un ` MyPrivateClass`.

Véase también QSharedPointer.

Documentación de funciones miembro

[explicit noexcept] QScopedPointer::QScopedPointer(T *p = nullptr)

Crea esta instancia de QScopedPointer y establece su puntero en p.

QScopedPointer::~QScopedPointer()

Destruye este objeto ` QScopedPointer `. Elimina el objeto al que apunta su puntero.

[noexcept] T *QScopedPointer::data() const

Devuelve el valor del puntero al que hace referencia este objeto. « QScopedPointer » sigue siendo el propietario del objeto al que apunta.

[noexcept] T *QScopedPointer::get() const

Es lo mismo que « data()».

[noexcept] bool QScopedPointer::isNull() const

Devuelve « true » si este objeto hace referencia a « nullptr ».

[noexcept(...)] void QScopedPointer::reset(T *other = nullptr)

Elimina el objeto existente al que apunta (si lo hay) y establece su puntero a other. QScopedPointer pasa a ser el propietario de other y lo eliminará en su destructor.

Nota: Esta función es «noexcept» cuando ` noexcept(Cleanup::cleanup(std::declval<T *>())) ` es ` true`.

[explicit] QScopedPointer::operator bool() const

Devuelve ` true ` si el puntero que contiene no es ` nullptr`. Esta función es adecuada para su uso en ` if-constructs`, como por ejemplo:

if (scopedPointer) {
    //...
}

Véase también isNull().

[noexcept] bool QScopedPointer::operator!() const

Devuelve ` true ` si este objeto hace referencia a ` nullptr`.

Véase también isNull().

T &QScopedPointer::operator*() const

Proporciona acceso al objeto del puntero en el ámbito.

Si el puntero contenido es de tip nullptr, el comportamiento es indefinido.

Véase también ` isNull()`.

[noexcept] T *QScopedPointer::operator->() const

Proporciona acceso al objeto del puntero en el ámbito.

Si el puntero contenido es de tip nullptr, el comportamiento es indefinido.

Véase también ` isNull()`.

Elementos no miembros relacionados

[noexcept] bool operator!=(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)

Devuelve « true » si « lhs » y « rhs » hacen referencia a punteros distintos.

[noexcept] bool operator!=(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t)

Devuelve ` true ` si ` lhs ` apunta a un puntero válido (es decir, no nulo).

Véase también QScopedPointer::isNull().

[noexcept] bool operator!=(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs)

Devuelve ` true ` si ` rhs ` apunta a un puntero válido (es decir, no nulo).

Véase también QScopedPointer::isNull().

[noexcept] bool operator==(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)

Devuelve ` true ` si ` lhs ` y ` rhs ` apuntan al mismo puntero.

[noexcept] bool operator==(const QScopedPointer<T, Cleanup> &lhs, std::nullptr_t)

Devuelve « true » si « lhs » hace referencia a « nullptr ».

Véase también QScopedPointer::isNull().

[noexcept] bool operator==(std::nullptr_t, const QScopedPointer<T, Cleanup> &rhs)

Devuelve « true » si « rhs » hace referencia a « nullptr ».

Véase también QScopedPointer::isNull().

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.