En esta página

QSharedPointer Class

template <typename T> class QSharedPointer

La clase `QSharedPointer` contiene una referencia fuerte a un puntero compartido. Más información...

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

Nota: Todas las funciones de esta clase son reentrantes.

Comparaciones de QSharedPointer

CategoríaTipos comparablesDescripción
strongQSharedPointer
strongQSharedPointer<X>, X* y std::nullptr_t.Donde X y T son tipos compatibles, lo que significa que son iguales o que uno es un tipo base del otro.

Funciones públicas

QSharedPointer()
QSharedPointer(QSharedPointer<X> &&other)
QSharedPointer(X *ptr)
QSharedPointer(const QWeakPointer<T> &other)
QSharedPointer(std::nullptr_t)
QSharedPointer(X *ptr, Deleter d)
QSharedPointer(std::nullptr_t, Deleter d)
QSharedPointer(const QSharedPointer<T> &other)
QSharedPointer(QSharedPointer<T> &&other)
~QSharedPointer()
void clear()
QSharedPointer<X> constCast() const &
(since 6.9) QSharedPointer<X> constCast() &&
T *data() const
QSharedPointer<X> dynamicCast() const &
(since 6.9) QSharedPointer<X> dynamicCast() &&
T *get() const
bool isNull() const
QSharedPointer<X> objectCast() const &
(since 6.9) QSharedPointer<X> objectCast() &&
(since 6.7) bool owner_before(const QSharedPointer<X> &other) const
(since 6.7) bool owner_before(const QWeakPointer<X> &other) const
(since 6.7) bool owner_equal(const QSharedPointer<X> &other) const
(since 6.7) bool owner_equal(const QWeakPointer<X> &other) const
(since 6.7) size_t owner_hash() const
void reset()
void reset(T *t)
void reset(T *t, Deleter deleter)
QSharedPointer<X> staticCast() const &
(since 6.9) QSharedPointer<X> staticCast() &&
void swap(QSharedPointer<T> &other)
QWeakPointer<T> toWeakRef() const
operator bool() const
bool operator!() const
T &operator*() const
T *operator->() const
QSharedPointer<T> &operator=(QSharedPointer<T> &&other)
QSharedPointer<T> &operator=(QSharedPointer<X> &&other)
QSharedPointer<T> &operator=(const QSharedPointer<T> &other)
QSharedPointer<T> &operator=(const QWeakPointer<T> &other)

Miembros públicos estáticos

QSharedPointer<T> create(Args &&... args)
size_t qHash(const QSharedPointer<T> &key, size_t seed = 0)
QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &other)
QSharedPointer<X> qSharedPointerCast(const QWeakPointer<T> &other)
(since 6.9) QSharedPointer<X> qSharedPointerCast(QSharedPointer<T> &&other)
QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &src)
QSharedPointer<X> qSharedPointerConstCast(const QWeakPointer<T> &src)
(since 6.9) QSharedPointer<X> qSharedPointerConstCast(QSharedPointer<T> &&src)
QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &src)
QSharedPointer<X> qSharedPointerDynamicCast(const QWeakPointer<T> &src)
(since 6.9) QSharedPointer<X> qSharedPointerDynamicCast(QSharedPointer<T> &&src)
QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &src)
QSharedPointer<X> qSharedPointerObjectCast(const QWeakPointer<T> &src)
std::shared_ptr<X> qSharedPointerObjectCast(const std::shared_ptr<T> &src)
std::shared_ptr<X> qSharedPointerObjectCast(std::shared_ptr<T> &&src)
(since 6.9) QSharedPointer<X> qSharedPointerObjectCast(QSharedPointer<T> &&src)
(since 6.12) QSharedPointer<X> qSharedPointerStaticCast(const QSharedPointer<T> &other)
(since 6.12) QSharedPointer<X> qSharedPointerStaticCast(const QWeakPointer<T> &other)
(since 6.12) QSharedPointer<X> qSharedPointerStaticCast(QSharedPointer<T> &&other)
std::shared_ptr<X> qobject_pointer_cast(const std::shared_ptr<T> &src)
std::shared_ptr<X> qobject_pointer_cast(std::shared_ptr<T> &&src)
bool operator!=(const QSharedPointer<T> &lhs, const QSharedPointer<X> &rhs)
bool operator!=(const QSharedPointer<T> &lhs, const X *rhs)
bool operator!=(const QSharedPointer<T> &lhs, std::nullptr_t)
bool operator!=(const T *lhs, const QSharedPointer<X> &rhs)
bool operator!=(std::nullptr_t, const QSharedPointer<T> &rhs)
QDebug operator<<(QDebug debug, const QSharedPointer<T> &ptr)
bool operator==(const QSharedPointer<T> &lhs, const QSharedPointer<X> &rhs)
bool operator==(const QSharedPointer<T> &lhs, const X *rhs)
bool operator==(const QSharedPointer<T> &lhs, std::nullptr_t)
bool operator==(const T *lhs, const QSharedPointer<X> &rhs)
bool operator==(std::nullptr_t, const QSharedPointer<T> &rhs)

Descripción detallada

QSharedPointer es un puntero compartido automático en C++, en el que el parámetro de plantilla T especifica el tipo del puntero que se gestiona. Se comporta exactamente igual que un puntero normal para fines habituales, incluyendo el respeto a la constancia.

QSharedPointer eliminará el puntero que mantiene cuando este salga del ámbito, siempre que ningún otro objeto QSharedPointer lo esté referenciando.

Un objeto QSharedPointer puede crearse a partir de un puntero normal, de otro objeto QSharedPointer o promoviendo un objeto QWeakPointer a una referencia fuerte.

Seguridad entre subprocesos

QSharedPointer y QWeakPointer son clases reentrantes. Esto significa que, en general, no se puede acceder a un objeto QSharedPointer o QWeakPointer determinado desde varios hilos al mismo tiempo sin sincronización.

Varios subprocesos pueden acceder de forma segura a diferentes objetos `QSharedPointer` y ` QWeakPointer ` al mismo tiempo. Esto incluye el caso en el que contienen punteros al mismo objeto; el mecanismo de recuento de referencias es atómico y no se requiere sincronización manual.

Cabe señalar que, aunque se puede acceder al valor del puntero de esta manera (es decir, mediante varios hilos al mismo tiempo, sin sincronización), QSharedPointer y QWeakPointer no ofrecen ninguna garantía sobre el objeto al que se apunta. Siguen siendo de aplicación las normas específicas de seguridad entre hilos y reentrancia para ese objeto.

Otras clases de punteros

Qt también proporciona otras dos clases envolventes de punteros: ` QPointer ` y ` QSharedDataPointer`. Son incompatibles entre sí, ya que cada una tiene un caso de uso muy diferente.

QSharedPointer contiene un puntero compartido mediante un recuento de referencias externo (es decir, un contador de referencias situado fuera del objeto). Como su nombre indica, el valor del puntero se comparte entre todas las instancias de `QSharedPointer` y ` QWeakPointer`. Sin embargo, el contenido del objeto al que apunta el puntero no debe considerarse compartido: solo hay un objeto. Por ese motivo, `QSharedPointer` no ofrece ninguna forma de desvincular o realizar copias del objeto al que apunta.

QSharedDataPointer QSharedData, por su parte, contiene un puntero a datos compartidos (es decir, una clase derivada de ). Lo hace mediante un recuento de referencias interno, ubicado en la clase base ` `. Esta clase puede, por lo tanto, desvincularse en función del tipo de acceso que se realice a los datos protegidos: si se trata de un acceso no `const`, crea una copia de forma atómica para que la operación se complete. QSharedData

QExplicitlySharedDataPointer es una variante de ` QSharedDataPointer`, salvo que solo se desvincula si se llama explícitamente a ` QExplicitlySharedDataPointer::detach()` (de ahí su nombre).

QScopedPointer Simplemente contiene un puntero a un objeto asignado en el montón y lo elimina en su destructor. Esta clase resulta útil cuando es necesario asignar un objeto en el montón y eliminarlo, pero nada más. ` QScopedPointer ` es ligera, ya que no utiliza estructuras adicionales ni recuento de referencias.

Por último, ` QPointer ` contiene un puntero a un objeto derivado de ` QObject`, pero lo hace de forma débil. ` QWeakPointer ` tiene la misma funcionalidad, pero su uso para esa función está en desuso.

Seguimiento opcional de punteros

Una característica de QSharedPointer que se puede habilitar en tiempo de compilación con fines de depuración es un mecanismo de seguimiento de punteros. Cuando está habilitado, QSharedPointer registra en un conjunto global todos los punteros que sigue. Esto permite detectar errores como asignar el mismo puntero a dos objetos QSharedPointer.

Esta función se activa definiendo la macro ` QT_SHAREDPOINTER_TRACK_POINTERS ` antes de incluir el encabezado de QSharedPointer.

Es seguro utilizar esta función incluso con código compilado sin ella. QSharedPointer se asegurará de que el puntero se elimine del rastreador incluso en el caso de código compilado sin seguimiento de punteros.

Sin embargo, hay que tener en cuenta que la función de seguimiento de punteros tiene limitaciones en casos de herencia múltiple o virtual (es decir, en casos en los que dos direcciones de puntero diferentes pueden hacer referencia al mismo objeto). En ese caso, si un puntero se convierte a un tipo diferente y su valor cambia, es posible que el mecanismo de seguimiento de punteros de QSharedPointer no detecte que el objeto al que se está realizando el seguimiento es el mismo.

Véase también QSharedDataPointer, QWeakPointer, QScopedPointer y QEnableSharedFromThis.

Documentación de las funciones miembro

QSharedPointer::QSharedPointer()

Crea un QSharedPointer que es nulo (el objeto contiene una referencia a nullptr).

[noexcept] template <typename X> QSharedPointer::QSharedPointer(QSharedPointer<X> &&other)

Crea una instancia de `QSharedPointer` mediante la construcción por movimiento, de modo que apunte al mismo objeto al que apuntaba ` other `.

Restricciones

Participa en la resolución de sobrecargas únicamente si ` X* ` se convierte implícitamente en ` T*`.

[explicit] template <typename X> QSharedPointer::QSharedPointer(X *ptr)

Crea un QSharedPointer que apunta a ptr. El puntero ptr pasa a estar gestionado por este QSharedPointer y no debe pasarse a otro objeto QSharedPointer ni eliminarse fuera de este objeto.

Desde Qt 5.8, cuando se destruye la última referencia a ptr, se eliminará llamando al destructor de X(incluso si X no es igual que el parámetro de plantilla de QSharedPointer, T). Anteriormente, se llamaba al destructor de T.

QSharedPointer::QSharedPointer(const QWeakPointer<T> &other)

Crea un QSharedPointer convirtiendo la referencia débil other en una referencia fuerte y compartiendo su puntero.

Si T es un tipo derivado del parámetro de plantilla de esta clase, QSharedPointer realizará una conversión automática. De lo contrario, se producirá un error de compilación.

Véase también QWeakPointer::toStrongRef().

QSharedPointer::QSharedPointer(std::nullptr_t)

Crea un QSharedPointer con valor nulo. Esto equivale al constructor por defecto de QSharedPointer.

template <typename X, typename Deleter> QSharedPointer::QSharedPointer(X *ptr, Deleter d)

Crea un QSharedPointer que apunta a ptr. El puntero ptr pasa a ser gestionado por este QSharedPointer y no debe pasarse a otro objeto QSharedPointer ni eliminarse fuera de este objeto.

El parámetro deleter d especifica el eliminador personalizado para este objeto. Se invoca el eliminador personalizado, en lugar del operador delete(), cuando el recuento de referencias fuertes desciende a 0. Esto resulta útil, por ejemplo, para llamar a deleteLater() en un QObject en lugar de:

static void doDeleteLater(MyObject *obj)
{
    obj->deleteLater();
}

void otherFunction()
{
    QSharedPointer<MyObject> obj =
        QSharedPointer<MyObject>(new MyObject, doDeleteLater);

    // continue using obj
    obj.clear();    // calls obj->deleteLater();
}

Ten en cuenta que la función de eliminador personalizada se invocará con un puntero al tipo X, incluso si el parámetro de plantilla de QSharedPointer T no es el mismo.

También es posible especificar una función miembro directamente, como en:

QSharedPointer<MyObject> obj =
    QSharedPointer<MyObject>(new MyObject, &QObject::deleteLater);

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

template <typename Deleter> QSharedPointer::QSharedPointer(std::nullptr_t, Deleter d)

Crea un QSharedPointer con valor nulo. Esto equivale al constructor por defecto de QSharedPointer.

El parámetro deleter d especifica el eliminador personalizado para este objeto. Se invoca el eliminador personalizado, en lugar del operador delete(), cuando el recuento de referencias fuertes desciende a 0.

QSharedPointer::QSharedPointer(const QSharedPointer<T> &other)

Crea un objeto `QSharedPointer` que comparte el puntero de ` other`.

Si ` T ` es un tipo derivado del parámetro de plantilla de esta clase, `QSharedPointer` realizará una conversión automática. De lo contrario, se producirá un error de compilación.

[noexcept] QSharedPointer::QSharedPointer(QSharedPointer<T> &&other)

Crea una instancia de `QSharedPointer` mediante la construcción por movimiento, de modo que apunte al mismo objeto al que apuntaba ` other `.

QSharedPointer::~QSharedPointer()

Destruye este objeto ` QSharedPointer `. Si se trata de la última referencia al puntero almacenado, esto también eliminará el puntero.

void QSharedPointer::clear()

Borra este objeto ` QSharedPointer `, eliminando la referencia que pudiera tener al puntero. Si esta era la última referencia, se eliminará el propio puntero.

template <typename X> QSharedPointer<X> QSharedPointer::constCast() const &

Realiza un « const_cast » del tipo de este puntero a « X » y devuelve un « QSharedPointer » que comparte la referencia. Esta función se puede utilizar tanto para el «up-casting» como para el «down-casting», pero resulta más útil para el «up-casting».

Véanse también ` isNull()` y ` qSharedPointerConstCast()`.

[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::constCast() &&

El objeto ` QSharedPointer ` devuelto comparte propiedad con el mismo conjunto de propietarios compartidos que ` *this`.

*this Esta función redirige resets a nullptr si la operación se realiza con éxito.

Esta función sobrecarga QSharedPointer::constCast().

Esta función se introdujo en Qt 6.9.

Véase también isNull() y qSharedPointerConstCast().

[static] template <typename... Args> QSharedPointer<T> QSharedPointer::create(Args &&... args)

Crea un objeto ` QSharedPointer ` y asigna un nuevo elemento de tipo ` T`. Los componentes internos de ` QSharedPointer ` y el objeto se asignan en una única asignación de memoria, lo que podría ayudar a reducir la fragmentación de la memoria en una aplicación de larga duración.

Esta función intentará llamar a un constructor del tipo ` T ` que pueda aceptar todos los argumentos pasados (`args`). Los argumentos se reenviarán íntegramente.

T *QSharedPointer::data() const

Devuelve el valor del puntero al que hace referencia este objeto.

Nota: no elimines el puntero devuelto por esta función ni lo pases a otra función que pueda eliminarlo, incluida la creación de objetos de tipo ` QSharedPointer ` o ` QWeakPointer `.

template <typename X> QSharedPointer<X> QSharedPointer::dynamicCast() const &

Realiza una conversión dinámica del tipo de este puntero a « X » y devuelve un « QSharedPointer » que comparte la referencia. Si esta función se utiliza para realizar una conversión ascendente, « QSharedPointer » llevará a cabo una « dynamic_cast », lo que significa que, si el objeto al que apunta este « QSharedPointer » no es de tipo « X », el objeto devuelto será nulo.

Nota: el tipo de plantilla X debe tener los mismos calificadores const y volatile que la plantilla de este objeto; de lo contrario, la conversión fallará. Utiliza constCast() si necesitas eliminar esos calificadores.

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

[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::dynamicCast() &&

El objeto ` QSharedPointer ` devuelto comparte la propiedad con el mismo conjunto de propietarios compartidos que ` *this`.

*this Esta función redirige resets a nullptr si la operación se realiza correctamente.

Esta función sobrecarga QSharedPointer::dynamicCast().

Esta función se introdujo en Qt 6.9.

Véase también qSharedPointerDynamicCast().

T *QSharedPointer::get() const

Es igual que data().

Esta función se proporciona para garantizar la compatibilidad de la API con std::shared_ptr.

bool QSharedPointer::isNull() const

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

template <typename X> QSharedPointer<X> QSharedPointer::objectCast() const &

Realiza una conversión de tipo « qobject_cast()» desde el tipo de este puntero a « X » y devuelve un « QSharedPointer » que comparte la referencia. Si esta función se utiliza para realizar un up-cast, « QSharedPointer » llevará a cabo una conversión de tipo « qobject_cast », lo que significa que, si el objeto al que apunta este « QSharedPointer » no es de tipo « X », el objeto devuelto será nulo.

Nota: el tipo de plantilla X debe tener los mismos calificadores const y volatile que la plantilla de este objeto; de lo contrario, la conversión fallará. Utiliza constCast() si necesitas eliminar esos calificadores.

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

[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::objectCast() &&

El objeto ` QSharedPointer ` devuelto comparte la propiedad con el mismo conjunto de propietarios compartidos que ` *this`.

*this Esta función redirige resets a nullptr si la operación se realiza correctamente.

Esta función sobrecarga QSharedPointer::objectCast().

Esta función se introdujo en Qt 6.9.

Véase también qSharedPointerObjectCast().

[noexcept, since 6.7] template <typename X> bool QSharedPointer::owner_before(const QSharedPointer<X> &other) const

[noexcept, since 6.7] template <typename X> bool QSharedPointer::owner_before(const QWeakPointer<X> &other) const

Devuelve ` true ` si y solo si este puntero inteligente precede a ` other ` en un orden basado en la propiedad definido por la implementación. El orden es tal que dos punteros inteligentes se consideran equivalentes si ambos están vacíos o si ambos son propietarios del mismo objeto (incluso si su tipo aparente y su puntero son diferentes).

Estas funciones se introdujeron en Qt 6.7.

Véase también owner_equal.

[noexcept, since 6.7] template <typename X> bool QSharedPointer::owner_equal(const QSharedPointer<X> &other) const

[noexcept, since 6.7] template <typename X> bool QSharedPointer::owner_equal(const QWeakPointer<X> &other) const

Devuelve ` true ` si y solo si este puntero inteligente y ` other ` comparten la propiedad.

Estas funciones se introdujeron en Qt 6.7.

Véase también owner_before y owner_hash.

[noexcept, since 6.7] size_t QSharedPointer::owner_hash() const

Devuelve un valor hash basado en el propietario para este objeto de puntero inteligente. Los punteros inteligentes que se consideren iguales (según owner_equal) tendrán un valor hash basado en el propietario idéntico.

Estas funciones se introdujeron en Qt 6.7.

Véase también owner_equal.

void QSharedPointer::reset()

Igual que ` clear()`. Para garantizar la compatibilidad con `std::shared_ptr`.

void QSharedPointer::reset(T *t)

Restablece este objeto ` QSharedPointer ` para que apunte a ` t `. Equivale a:

QSharedPointer<T> other(t); this->swap(other);

template <typename Deleter> void QSharedPointer::reset(T *t, Deleter deleter)

Restablece este objeto ` QSharedPointer ` para que apunte a ` t `, con el `Deleter` ` deleter`. Equivalente a:

QSharedPointer<T> other(t, deleter); this->swap(other);

template <typename X> QSharedPointer<X> QSharedPointer::staticCast() const &

Realiza una conversión estática del tipo de este puntero a ` X ` y devuelve un ` QSharedPointer ` que comparte la referencia. Esta función se puede utilizar tanto para conversiones ascendentes como descendentes, pero resulta más útil para las conversiones ascendentes.

Nota: el tipo de plantilla ` X ` debe tener los mismos calificadores `const` y `volatile` que la plantilla de este objeto; de lo contrario, la conversión fallará. Utiliza ` constCast()` si necesitas eliminar esos calificadores.

Véase también dynamicCast(), constCast() y qSharedPointerStaticCast().

[since 6.9] template <typename X> QSharedPointer<X> QSharedPointer::staticCast() &&

El objeto ` QSharedPointer ` devuelto comparte la propiedad con el mismo conjunto de propietarios compartidos que ` *this`.

*this Esta función redirige resets a nullptr si la operación se realiza correctamente.

Esta función sobrecarga QSharedPointer::staticCast().

Esta función se introdujo en Qt 6.9.

Véase también dynamicCast(), constCast() y qSharedPointerStaticCast().

[noexcept] void QSharedPointer::swap(QSharedPointer<T> &other)

Intercambia esta instancia de puntero compartido con other. Esta operación es muy rápida y nunca falla.

QWeakPointer<T> QSharedPointer::toWeakRef() const

Devuelve un objeto de referencia débil que comparte el puntero al que hace referencia este objeto.

Véase también QWeakPointer::QWeakPointer().

QSharedPointer::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 (sharedptr) { /*...*/ }

Véase también isNull().

bool QSharedPointer::operator!() const

Devuelve « true » si este objeto hace referencia a « nullptr ». Esta función es adecuada para su uso en « if-constructs », como por ejemplo:

if (!sharedptr) { /*...*/ }

Véase también isNull().

T &QSharedPointer::operator*() const

Permite acceder a los miembros del puntero compartido.

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

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

T *QSharedPointer::operator->() const

Permite acceder a los miembros del puntero compartido.

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

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

[noexcept] QSharedPointer<T> &QSharedPointer::operator=(QSharedPointer<T> &&other)

Asigna « other » a esta instancia de « QSharedPointer ». . . . . . . . . . . . . . . . . . . . . . . . . .xml-ph-0001@

[noexcept] template <typename X> QSharedPointer<T> &QSharedPointer::operator=(QSharedPointer<X> &&other)

Asigna mediante «move» la variable ` other ` a esta instancia de ` QSharedPointer `.

Restricciones

Participa en la resolución de sobrecargas únicamente si ` X* ` se convierte implícitamente en ` T*`.

QSharedPointer<T> &QSharedPointer::operator=(const QSharedPointer<T> &other)

Hace que este objeto comparta el puntero de ` other`. La referencia al puntero actual se descarta y, si era la última, el puntero se eliminará.

Si T es un tipo derivado del parámetro de plantilla de esta clase, QSharedPointer realizará una conversión automática. De lo contrario, se producirá un error de compilación.

QSharedPointer<T> &QSharedPointer::operator=(const QWeakPointer<T> &other)

Convierte ` other ` en una referencia fuerte y hace que este objeto comparta una referencia al puntero al que hace referencia. La referencia de puntero actual se descarta y, si era la última, el puntero se eliminará.

Si ` T ` es un tipo derivado del parámetro de plantilla de esta clase, ` QSharedPointer ` realizará una conversión automática. De lo contrario, se producirá un error de compilación.

Elementos no miembros relacionados

[noexcept] template <typename T> size_t qHash(const QSharedPointer<T> &key, size_t seed = 0)

Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.

template <typename X, typename T> QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &other)

Devuelve un puntero compartido al puntero que contiene other, convertido al tipo X. Los tipos T y X deben pertenecer a una misma jerarquía para que static_cast se ejecute correctamente.

Ten en cuenta que ` X ` debe tener los mismos calificadores cv (const y volatile) que ` T `, o el código no se compilará. Utiliza ` qSharedPointerConstCast ` para eliminar la constancia.

Véase también QSharedPointer::staticCast(), qSharedPointerDynamicCast() y qSharedPointerConstCast().

template <typename X, typename T> QSharedPointer<X> qSharedPointerCast(const QWeakPointer<T> &other)

Devuelve un puntero compartido al puntero que contiene ` other`, convertido al tipo ` X`. Los tipos ` T ` y ` X ` deben pertenecer a una misma jerarquía para que ` static_cast ` se ejecute correctamente.

El objeto other se convierte primero en una referencia fuerte. Si esa conversión falla (porque el objeto al que apunta ya se ha eliminado), esta función devuelve un QSharedPointer nulo.

Ten en cuenta que X debe tener los mismos calificadores cv (const y volatile) que T, o el código no se compilará. Utiliza qSharedPointerConstCast para eliminar la constante.

Véase también QWeakPointer::toStrongRef(), qSharedPointerDynamicCast() y qSharedPointerConstCast().

[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerCast(QSharedPointer<T> &&other)

El objeto ` QSharedPointer ` devuelto comparte la propiedad con el mismo conjunto de propietarios compartidos que ` other`.

Esta función resets other a nullptr si la operación se realiza con éxito.

Esta función sobrecarga QSharedPointer::qSharedPointerCast(const QSharedPointer<T> &other).

Esta función se introdujo en Qt 6.9.

Véase también QSharedPointer::staticCast(), qSharedPointerDynamicCast() y qSharedPointerConstCast().

template <typename X, typename T> QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &src)

Devuelve un puntero compartido al puntero que contiene src, convertido al tipo X. Los tipos T y X deben pertenecer a una misma jerarquía para que la const_cast se realice correctamente. Se ignoran las diferencias const y volatile entre T y X.

Véase también QSharedPointer::constCast(), qSharedPointerStaticCast() y qSharedPointerDynamicCast().

template <typename X, typename T> QSharedPointer<X> qSharedPointerConstCast(const QWeakPointer<T> &src)

Devuelve un puntero compartido al puntero que contiene ` src`, convertido al tipo ` X`. Los tipos ` T ` y ` X ` deben pertenecer a una misma jerarquía para que ` const_cast ` se ejecute correctamente. Se ignoran las diferencias entre ` const ` y ` volatile ` que existen entre ` T ` y ` X `.

El objeto src se convierte primero en una referencia fuerte. Si esa conversión falla (porque el objeto al que apunta ya se ha eliminado), esta función devuelve un QSharedPointer nulo.

Véase también QWeakPointer::toStrongRef(), qSharedPointerStaticCast() y qSharedPointerDynamicCast().

[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerConstCast(QSharedPointer<T> &&src)

El objeto ` QSharedPointer ` devuelto comparte la propiedad con el mismo conjunto de propietarios compartidos que ` src`.

Esta función resets src a nullptr si se ejecuta correctamente.

Esta función sobrecarga QSharedPointer::qSharedPointerConstCast(const QSharedPointer<T> &src).

Esta función se introdujo en Qt 6.9.

Véase también QSharedPointer::constCast(), qSharedPointerStaticCast() y qSharedPointerDynamicCast().

template <typename X, typename T> QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &src)

Devuelve un puntero compartido al puntero que contiene ` src`, utilizando un `dynamic cast` al tipo ` X ` para obtener un puntero interno del tipo adecuado. Si el ` dynamic_cast ` falla, el objeto devuelto será nulo.

Ten en cuenta que X debe tener los mismos calificadores cv (const y volatile) que T, o el código no se compilará. Utiliza qSharedPointerConstCast para eliminar la constante.

Véase también QSharedPointer::dynamicCast(), qSharedPointerStaticCast() y qSharedPointerConstCast().

template <typename X, typename T> QSharedPointer<X> qSharedPointerDynamicCast(const QWeakPointer<T> &src)

Devuelve un puntero compartido al puntero que contiene ` src`, utilizando un `dynamic cast` al tipo ` X ` para obtener un puntero interno del tipo adecuado. Si el ` dynamic_cast ` falla, el objeto devuelto será `null`.

El objeto ` src ` se convierte primero en una referencia fuerte. Si dicha conversión falla (porque el objeto al que apunta ya ha sido eliminado), esta función también devuelve un ` QSharedPointer` nulo.

Ten en cuenta que X debe tener los mismos calificadores cv (const y volatile) que T, o el código no se compilará. Utiliza qSharedPointerConstCast para eliminar la constancia.

Véase también QWeakPointer::toStrongRef(), qSharedPointerStaticCast() y qSharedPointerConstCast().

[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerDynamicCast(QSharedPointer<T> &&src)

El objeto ` QSharedPointer ` devuelto comparte la propiedad con el mismo conjunto de propietarios compartidos que ` src`.

Esta función resets src a nullptr si se ejecuta con éxito.

Esta función sobrecarga QSharedPointer::qSharedPointerDynamicCast(const QSharedPointer<T> &src).

Esta función se introdujo en Qt 6.9.

Véanse también QSharedPointer::dynamicCast(), qSharedPointerStaticCast() y qSharedPointerConstCast().

template <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &src)

La función `qSharedPointerObjectCast` sirve para realizar una conversión de un puntero compartido.

Devuelve un puntero compartido al puntero que contiene ` src`, utilizando ` qobject_cast()` para convertir ` X ` y obtener así un puntero interno del tipo adecuado. Si la conversión ` qobject_cast ` falla, el objeto devuelto será nulo.

Ten en cuenta que X debe tener los mismos calificadores cv (const y volatile) que T, o el código no se compilará. Utiliza qSharedPointerConstCast para eliminar la constante.

Véase también QSharedPointer::objectCast(), qSharedPointerStaticCast() y qSharedPointerConstCast().

template <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(const QWeakPointer<T> &src)

La función `qSharedPointerObjectCast` sirve para realizar la conversión de un puntero compartido.

Devuelve un puntero compartido al objeto al que apunta ` src`, utilizando ` qobject_cast()` para convertir ` X ` y obtener así un puntero interno del tipo adecuado. Si la conversión ` qobject_cast ` falla, el objeto devuelto será nulo.

El objeto src se convierte primero en una referencia fuerte. Si esa conversión falla (porque el objeto al que apunta ya ha sido eliminado), esta función también devuelve un QSharedPointer nulo.

Ten en cuenta que X debe tener los mismos calificadores cv (const y volatile) que T, o el código no se compilará. Utiliza qSharedPointerConstCast para eliminar la constante.

Véase también QWeakPointer::toStrongRef(), qSharedPointerStaticCast() y qSharedPointerConstCast().

template <typename X, typename T> std::shared_ptr<X> qSharedPointerObjectCast(const std::shared_ptr<T> &src)

Devuelve un puntero compartido al puntero que contiene src, utilizando un qobject_cast() para convertir X y obtener así un puntero interno del tipo adecuado. Si la qobject_cast falla, el objeto devuelto será nulo.

Ten en cuenta que ` X ` debe tener los mismos calificadores `cv` (`const ` y ` volatile`) que ` T `, o el código no se compilará. Utiliza `const_pointer_cast` para eliminar el carácter «const».

template <typename X, typename T> std::shared_ptr<X> qSharedPointerObjectCast(std::shared_ptr<T> &&src)

Devuelve un puntero compartido al puntero que contiene ` src`, utilizando ` qobject_cast()` para convertir ` X ` y obtener así un puntero interno del tipo adecuado.

Si la llamada a ` qobject_cast ` tiene éxito, la función devolverá un puntero compartido válido y ` src ` se restablecerá a `null`. Si la llamada a ` qobject_cast ` falla, el objeto devuelto será `null` y ` src ` no se modificará.

Ten en cuenta que X debe tener los mismos calificadores cv (const y volatile) que T, o el código no se compilará. Utiliza const_pointer_cast para eliminar la constante.

[since 6.9] template <typename X, typename T> QSharedPointer<X> qSharedPointerObjectCast(QSharedPointer<T> &&src)

El objeto ` QSharedPointer ` devuelto comparte la propiedad con el mismo conjunto de propietarios compartidos que ` src`.

Esta función resets src a nullptr si la operación se realiza correctamente.

Esta función sobrecarga QSharedPointer::qSharedPointerObjectCast(const QSharedPointer<T> &src).

Esta función se introdujo en Qt 6.9.

Véase también QSharedPointer::objectCast(), qSharedPointerStaticCast() y qSharedPointerConstCast().

[since 6.12] template <typename X, typename T> QSharedPointer<X> qSharedPointerStaticCast(const QSharedPointer<T> &other)

Devuelve un puntero compartido al puntero que contiene ` other`, convertido al tipo ` X`. Los tipos ` T ` y ` X ` deben pertenecer a una misma jerarquía para que la llamada a ` static_cast ` se realice con éxito.

Ten en cuenta que X debe tener los mismos calificadores cv (const y volatile) que T; de lo contrario, el código no se compilará. Utiliza qSharedPointerConstCast para eliminar el carácter const.

Esta función se introdujo en Qt 6.12.

Véase también QSharedPointer::staticCast(), qSharedPointerDynamicCast() y qSharedPointerConstCast().

[since 6.12] template <typename X, typename T> QSharedPointer<X> qSharedPointerStaticCast(const QWeakPointer<T> &other)

Devuelve un puntero compartido al puntero que contiene ` other`, convertido al tipo ` X`. Los tipos ` T ` y ` X ` deben pertenecer a una misma jerarquía para que la llamada a ` static_cast ` se realice con éxito.

El objeto ` other ` se convierte primero en una referencia fuerte. Si esa conversión falla (porque el objeto al que apunta ya ha sido eliminado), esta función devuelve un ` QSharedPointer` nulo.

Ten en cuenta que X debe tener los mismos calificadores cv (const y volatile) que T, o el código no se compilará. Utiliza qSharedPointerConstCast para eliminar la constante.

Esta función se introdujo en Qt 6.12.

Véase también QWeakPointer::toStrongRef(), qSharedPointerDynamicCast() y qSharedPointerConstCast().

[since 6.12] template <typename X, typename T> QSharedPointer<X> qSharedPointerStaticCast(QSharedPointer<T> &&other)

El objeto ` QSharedPointer ` devuelto comparte la propiedad con el mismo conjunto de propietarios compartidos que ` other`.

Esta función reasigna el puntero resets other a nullptr si la operación se realiza con éxito.

Esta función sobrecarga QSharedPointer::qSharedPointerStaticCast(const QSharedPointer<T> &other).

Esta función se introdujo en Qt 6.12.

Véase también QSharedPointer::staticCast(), qSharedPointerDynamicCast() y qSharedPointerConstCast().

template <typename X, typename T> std::shared_ptr<X> qobject_pointer_cast(const std::shared_ptr<T> &src)

Devuelve un puntero compartido al puntero que contiene ` src`.

Es lo mismo que qSharedPointerObjectCast(). Esta función se proporciona para garantizar la compatibilidad con la STL.

template <typename X, typename T> std::shared_ptr<X> qobject_pointer_cast(std::shared_ptr<T> &&src)

Es lo mismo que ` qSharedPointerObjectCast()`. Esta función se incluye para garantizar la compatibilidad con la STL.

template <typename T, typename X> bool operator!=(const QSharedPointer<T> &lhs, const QSharedPointer<X> &rhs)

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

Si el parámetro de plantilla de rhs es diferente al de lhs, QSharedPointer debe asegurarse primero de que sean tipos compatibles. Intentará realizar una « static_cast » automática para convertir los tipos T y X a su tipo de puntero compuesto. Si el parámetro de plantilla de rhs no es un tipo base ni un tipo derivado de lhs, se producirá un error de compilación.

template <typename T, typename X> bool operator!=(const QSharedPointer<T> &lhs, const X *rhs)

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

Si el parámetro de plantilla de ` rhs` es diferente al de ` lhs`, ` QSharedPointer ` debe asegurarse primero de que sean tipos compatibles. Intentará realizar una « static_cast » automática para convertir los tipos ` T ` y ` X ` a su tipo de puntero compuesto. Si el parámetro de plantilla de ` rhs` no es un tipo base ni un tipo derivado del de ` lhs`, se producirá un error de compilación.

template <typename T> bool operator!=(const QSharedPointer<T> &lhs, std::nullptr_t)

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

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

template <typename T, typename X> bool operator!=(const T *lhs, const QSharedPointer<X> &rhs)

Devuelve ` true ` si el puntero ` lhs ` no es el mismo puntero al que hace referencia ` rhs`.

Si el parámetro de plantilla de rhs es diferente al de lhs, QSharedPointer debe asegurarse primero de que sean tipos compatibles. Intentará realizar una « static_cast » automática para convertir los tipos T y X a su tipo de puntero compuesto. Si el parámetro de plantilla de rhs no es un tipo base ni un tipo derivado de lhs, se producirá un error de compilación.

template <typename T> bool operator!=(std::nullptr_t, const QSharedPointer<T> &rhs)

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

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

template <typename T> QDebug operator<<(QDebug debug, const QSharedPointer<T> &ptr)

Escribe el puntero al que hace referencia ptr en el objeto de depuración debug con fines de depuración.

Véase también «Técnicas de depuración».

template <typename T, typename X> bool operator==(const QSharedPointer<T> &lhs, const QSharedPointer<X> &rhs)

Devuelve « true » si « lhs » y « rhs » hacen referencia al mismo puntero.

Si el parámetro de plantilla de ` rhs` es diferente al de ` lhs`, ` QSharedPointer ` debe asegurarse primero de que sean tipos compatibles. Intentará realizar una « static_cast » automática para convertir los tipos ` T ` y ` X ` a su tipo de puntero compuesto. Si el parámetro de plantilla de ` rhs` no es un tipo base ni un tipo derivado de ` lhs`, se producirá un error de compilación.

template <typename T, typename X> bool operator==(const QSharedPointer<T> &lhs, const X *rhs)

Devuelve ` true ` si ` lhs ` y ` rhs ` hacen referencia al mismo puntero.

Si el parámetro de plantilla de ` rhs` es diferente al de ` lhs`, ` QSharedPointer ` debe asegurarse primero de que sean tipos compatibles. Intentará realizar una « static_cast » automática para convertir los tipos ` T ` y ` X ` a su tipo de puntero compuesto. Si el parámetro de plantilla de ` rhs` no es un tipo base ni un tipo derivado de ` lhs`, se producirá un error de compilación.

template <typename T> bool operator==(const QSharedPointer<T> &lhs, std::nullptr_t)

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

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

template <typename T, typename X> bool operator==(const T *lhs, const QSharedPointer<X> &rhs)

Devuelve ` true ` si el puntero ` lhs ` es el mismo puntero al que hace referencia ` rhs`.

Si el parámetro de plantilla de ` rhs` es diferente al de ` lhs`, ` QSharedPointer ` debe asegurarse primero de que se trate de tipos compatibles. Intentará realizar una « static_cast » automática para convertir los tipos ` T ` y ` X ` a su tipo de puntero compuesto. Si el parámetro de plantilla de ` rhs` no es un tipo base ni un tipo derivado del de ` lhs`, se producirá un error del compilador.

template <typename T> bool operator==(std::nullptr_t, const QSharedPointer<T> &rhs)

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

Véase también QSharedPointer::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.