QScopedPointer Class
template <typename T, typename Cleanup> class QScopedPointerLa 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: |
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 |
Elementos no miembros relacionados
| 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.