QPointer Class
template <typename T> class QPointerLa clase `QPointer` es una clase de plantilla que proporciona punteros protegidos a ` QObject`. Más información...
| Encabezado: | #include <QPointer> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
Comparaciones de QPointer
| Categoría | Tipos comparables | Descripción |
|---|---|---|
| igualdad | QPointer | |
| igualdad | QPointer<X>, X* y std::nullptr_t. | Donde X y T son tipos compatibles, lo que significa que son iguales (salvo por sus calificadores cv) o que uno es un tipo base del otro. |
Funciones públicas
| QPointer() | |
(since 6.6) | QPointer(QPointer<X> &&other) |
| QPointer(T *p) | |
(since 6.6) | QPointer(const QPointer<X> &other) |
| QPointer(std::nullptr_t) | |
| ~QPointer() | |
| void | clear() |
| T * | data() const |
(since 6.0) T * | get() const |
| bool | isNull() const |
| void | swap(QPointer<T> &other) |
| operator T *() const | |
| T & | operator*() const |
| T * | operator->() const |
(since 6.6.1) QPointer<T> & | operator=(QPointer<X> &&other) |
| QPointer<T> & | operator=(T *p) |
(since 6.6) QPointer<T> & | operator=(const QPointer<X> &other) |
Elementos no miembros relacionados
| bool | operator!=(X *const &lhs, const QPointer<T> &rhs) |
| bool | operator!=(const QPointer<T> &lhs, X *const &rhs) |
| bool | operator!=(const QPointer<T> &lhs, const QPointer<X> &rhs) |
| bool | operator!=(const QPointer<T> &lhs, const std::nullptr_t &rhs) |
| bool | operator!=(const std::nullptr_t &lhs, const QPointer<T> &rhs) |
| bool | operator==(X *const &lhs, const QPointer<T> &rhs) |
| bool | operator==(const QPointer<T> &lhs, X *const &rhs) |
| bool | operator==(const QPointer<T> &lhs, const QPointer<X> &rhs) |
| bool | operator==(const QPointer<T> &lhs, const std::nullptr_t &rhs) |
| bool | operator==(const std::nullptr_t &lhs, const QPointer<T> &rhs) |
Descripción detallada
Un puntero protegido, QPointer<T>, se comporta como un puntero normal de C++ T *, salvo que se borra automáticamente cuando se destruye el objeto al que hace referencia (a diferencia de los punteros normales de C++, que en tales casos se convierten en «punteros colgantes»). El parámetro de plantilla ` T ` especifica el tipo derivado de ` QObject` al que se apunta; ` T ` debe ser una subclase de ` QObject`.
Los punteros protegidos resultan útiles siempre que se necesite almacenar un puntero a un QObject que sea propiedad de otra entidad y que, por lo tanto, pueda ser destruido mientras aún se mantiene una referencia al mismo. Se puede comprobar de forma segura la validez del puntero.
Ten en cuenta que Qt 5 introduce un ligero cambio en el comportamiento al utilizar QPointer.
- Al utilizar QPointer con un ` QWidget ` (o una subclase de ` QWidget`), anteriormente el QPointer se borraba mediante el destructor ` QWidget `. Ahora, el QPointer se borra mediante el destructor ` QObject ` (ya que es en ese momento cuando se borran los objetos de ` QWeakPointer `). N ingún QPointer que haga un seguimiento de un widget se borrará antes de que el destructor QWidget destruya los elementos secundarios del widget al que se está realizando el seguimiento.
Qt también proporciona QSharedPointer, una implementación de un objeto de puntero compartido con recuento de referencias, que puede utilizarse para mantener una colección de referencias a un puntero concreto.
Ejemplo:
Si el ` QLabel ` se elimina mientras tanto, la variable ` label ` contendrá ` nullptr ` en lugar de una dirección inválida, y la última línea nunca se ejecutará.
Las funciones y operadores disponibles con un QPointer son los mismos que los disponibles con un puntero normal sin protección, excepto los operadores aritméticos de punteros (+, -, ++ y --), que normalmente solo se utilizan con matrices de objetos.
Utiliza los QPointers como punteros normales y no necesitarás leer la documentación de esta clase.
Para crear punteros protegidos, puedes construirlos o asignarles un valor a partir de un T* o de otro puntero protegido del mismo tipo. Puedes compararlos entre sí utilizando los operadores ==() y !=(), o comprobar si son de tipo nullptr con isNull(). Puedes desreferenciarlos utilizando la notación *x o la x->member.
Un puntero protegido se convertirá automáticamente a un * T, por lo que puedes mezclar libremente punteros protegidos y no protegidos. Esto significa que, si tienes un QPointer<QWidget>, puedes pasarlo a una función que requiera un QWidget *. Por este motivo, no tiene mucho sentido declarar funciones que acepten un QPointer como parámetro; basta con utilizar punteros normales. Utiliza un QPointer cuando vayas a almacenar un puntero durante un tiempo.
Ten en cuenta que la clase T debe heredar de QObject; de lo contrario, se producirá un error de compilación o de enlace.
Véase también QSharedPointer, QObject y QObjectCleanupHandler.
Documentación de las funciones miembro
[noexcept default] QPointer::QPointer()
[constexpr noexcept] QPointer::QPointer(std::nullptr_t)
Crea un puntero protegido con el valor nullptr.
Véase también isNull().
[noexcept, since 6.6] template <typename X> requires if_convertible<X> QPointer::QPointer(QPointer<X> &&other)
[noexcept, since 6.6] template <typename X> requires if_convertible<X> QPointer::QPointer(const QPointer<X> &other)
Constructor de conversión. Crea un nuevo objeto ` QPointer ` moviendo o copiando el contenido de ` other`.
El objeto ` QPointer ` del que se ha realizado la migración se restablece a `nullptr`.
Nota: Estos constructores participan en la resolución de sobrecarga solo si ` X* ` es convertible a ` T*`.
Estas funciones se introdujeron en Qt 6.6.
QPointer::QPointer(T *p)
Crea un puntero protegido que apunta al mismo objeto al que apunta p.
QPointer::~QPointer()
Destruye el puntero protegido. Al igual que ocurre con un puntero normal, al destruir un puntero protegido no se destruye el objeto al que apunta.
[noexcept] void QPointer::clear()
Borra este objeto « QPointer ».
Véase también isNull().
[noexcept] T *QPointer::data() const
Devuelve el puntero al objeto protegido.
[noexcept, since 6.0] T *QPointer::get() const
Es igual que ` data()`. Esta función se ofrece para garantizar la compatibilidad con STL.
Esta función se introdujo en Qt 6.0.
[noexcept] bool QPointer::isNull() const
Devuelve « true » si el objeto al que se hace referencia ha sido destruido o si no existe ningún objeto al que se haga referencia; en caso contrario, devuelve « false ».
[noexcept] void QPointer::swap(QPointer<T> &other)
Intercambia este puntero con other. Esta operación es muy rápida y nunca falla.
[noexcept] QPointer::operator T *() const
Operador de conversión; implementa la semántica de los punteros. Gracias a esta función, se puede pasar un QPointer<T> a una función en la que se requiera un T*.
[noexcept] T &QPointer::operator*() const
Operador de desreferencia; implementa la semántica de los punteros. Basta con utilizar este operador tal y como lo harías con un puntero normal de C++.
[noexcept] T *QPointer::operator->() const
Operador de flecha sobrecargado; implementa la semántica de los punteros. Basta con utilizar este operador tal y como lo harías con un puntero normal de C++.
[noexcept, since 6.6.1] template <typename X> requires if_convertible<X> QPointer<T> &QPointer::operator=(QPointer<X> &&other)
Operador de conversión y asignación. Hace que este puntero protegido proteja el mismo objeto que protege « other » y restablece « other » a «nullptr».
Restricciones
Participa en la resolución de sobrecargas solo si X* es convertible a T*.
Esta función se introdujo en Qt 6.6.1.
QPointer<T> &QPointer::operator=(T *p)
Operador de asignación. Este puntero protegido apuntará ahora al mismo objeto al que apunta p.
[noexcept, since 6.6] template <typename X> requires if_convertible<X> QPointer<T> &QPointer::operator=(const QPointer<X> &other)
Operador de asignación de conversión. Hace que este puntero protegido proteja el mismo objeto que protege other.
Restricciones
Participa en la resolución de sobrecargas solo si X* es convertible a T*.
Esta función se introdujo en Qt 6.6.
Elementos no miembros relacionados
[noexcept] template <typename X> bool operator!=(X *const &lhs, const QPointer<T> &rhs)
Operador de desigualdad. Devuelve « true » si « lhs » y el puntero protegido « rhs » no apuntan al mismo objeto; en caso contrario, devuelve « false ».
[noexcept] template <typename X> bool operator!=(const QPointer<T> &lhs, X *const &rhs)
Operador de desigualdad. Devuelve « true » si « rhs » y el puntero protegido « lhs » no apuntan al mismo objeto; en caso contrario, devuelve « false ».
[noexcept(...)] template <typename X> bool operator!=(const QPointer<T> &lhs, const QPointer<X> &rhs)
Operador de desigualdad. Devuelve « true » si los punteros protegidos « lhs » y « rhs » no apuntan al mismo objeto; en caso contrario, devuelve « false ».
Nota: Esta función es «noexcept» cuando true es true.
[noexcept] bool operator!=(const QPointer<T> &lhs, const std::nullptr_t &rhs)
Operador de desigualdad. Devuelve ` true ` si el puntero protegido por ` lhs ` es un puntero válido (es decir, no ` nullptr`); en caso contrario, devuelve ` false`.
[noexcept] bool operator!=(const std::nullptr_t &lhs, const QPointer<T> &rhs)
Operador de desigualdad. Devuelve ` true ` si el puntero protegido por ` rhs ` es un puntero válido (es decir, no ` nullptr`); en caso contrario, devuelve ` false`.
[noexcept] template <typename X> bool operator==(X *const &lhs, const QPointer<T> &rhs)
Operador de igualdad. Devuelve « true » si « lhs » y el puntero protegido « rhs » apuntan al mismo objeto; en caso contrario, devuelve « false ».
[noexcept] template <typename X> bool operator==(const QPointer<T> &lhs, X *const &rhs)
Operador de igualdad. Devuelve « true » si « rhs » y el puntero protegido « lhs » apuntan al mismo objeto; en caso contrario, devuelve « false ».
[noexcept(...)] template <typename X> bool operator==(const QPointer<T> &lhs, const QPointer<X> &rhs)
Operador de igualdad. Devuelve « true » si los punteros protegidos « lhs » y « rhs » apuntan al mismo objeto; en caso contrario, devuelve « false ».
Nota: Esta función es «noexcept» cuando ` true ` es ` true`.
[noexcept] bool operator==(const QPointer<T> &lhs, const std::nullptr_t &rhs)
Operador de igualdad. Devuelve « true » si el puntero protegido por « lhs » es « nullptr »; en caso contrario, devuelve « false ».
[noexcept] bool operator==(const std::nullptr_t &lhs, const QPointer<T> &rhs)
Operador de igualdad. Devuelve « true » si el puntero protegido por « rhs » es « nullptr »; en caso contrario, devuelve « false ».
© 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.