En esta página

QExplicitlySharedDataPointer Class

template <typename T> class QExplicitlySharedDataPointer

La clase `QExplicitlySharedDataPointer` representa un puntero a un objeto compartido explícitamente. Más información...

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

Nota: Todas las funciones de esta clase son reentrantes.

Comparaciones de QExplicitlySharedDataPointer

CategoríaTipos comparables
strongQExplicitlySharedDataPointer
strongT* y std::nullptr_t.

Tipos públicos

Funciones públicas

QExplicitlySharedDataPointer()
QExplicitlySharedDataPointer(T *data)
QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<X> &o)
QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T> &o)
QExplicitlySharedDataPointer(QExplicitlySharedDataPointer<T> &&o)
~QExplicitlySharedDataPointer()
const T *constData() const
T *data() const
void detach()
(since 6.0) T *get() const
(since 6.0) void reset(T *ptr = nullptr)
void swap(QExplicitlySharedDataPointer<T> &other)
T *take()
operator bool() const
bool operator!() const
T &operator*() const
T *operator->()
T *operator->() const
QExplicitlySharedDataPointer<T> &operator=(QExplicitlySharedDataPointer<T> &&other)
QExplicitlySharedDataPointer<T> &operator=(T *o)
QExplicitlySharedDataPointer<T> &operator=(const QExplicitlySharedDataPointer<T> &o)

Funciones protegidas

T *clone()
bool operator!=(const QExplicitlySharedDataPointer<T> &lhs, const QExplicitlySharedDataPointer<T> &rhs)
bool operator!=(const T *const &lhs, const QExplicitlySharedDataPointer<T> &rhs)
bool operator==(const QExplicitlySharedDataPointer<T> &lhs, const QExplicitlySharedDataPointer<T> &rhs)
bool operator==(const T *const &lhs, const QExplicitlySharedDataPointer<T> &rhs)

Descripción detallada

QExplicitlySharedDataPointer es una clase de plantilla en la que el parámetro de plantilla T especifica el tipo de la clase de datos compartidos que deriva de QSharedData.

QExplicitlySharedDataPointer<T> facilita la creación de tus propias clases compartidas explícitamente. QExplicitlySharedDataPointer implementa un recuento de referencias seguro para subprocesos, lo que garantiza que añadir QExplicitlySharedDataPointers a tus clases reentrantes no las convierta en no reentrantes.

Salvo por una gran diferencia, `QExplicitlySharedDataPointer` es igual que ` QSharedDataPointer`. La gran diferencia es que las funciones miembro de `QExplicitlySharedDataPointer` no realizan la operación automática de copia al escribir (`detach()`) que realizan los miembros no const de ` QSharedDataPointer ` antes de permitir que se modifique el objeto de datos compartidos. Existe una función detach(), pero si realmente quieres detach(), tienes que llamarla tú mismo. Esto significa que los QExplicitlySharedDataPointers se comportan como punteros normales de C++, salvo que, al realizar el recuento de referencias y no eliminar el objeto de datos compartido hasta que el recuento de referencias sea 0, evitan el problema de los punteros colgantes.

Resulta instructivo comparar QExplicitlySharedDataPointer con QSharedDataPointer mediante un ejemplo. Considera el Employee example en QSharedDataPointer, modificado para utilizar el uso compartido explícito tal y como se explica en el debate Implicit vs Explicit Sharing.

Ten en cuenta que, si utilizas esta clase pero observas que estás llamando a ` detach()` con mucha frecuencia, probablemente deberías utilizar ` QSharedDataPointer ` en su lugar.

En la documentación de la función miembro, el puntero `d` siempre hace referencia al puntero interno al objeto de datos compartido.

Véase también QSharedData y QSharedDataPointer.

Documentación sobre tipos de miembros

QExplicitlySharedDataPointer::Type

Este es el tipo del objeto de datos compartido. El puntero `d` apunta a un objeto de este tipo.

Documentación de las funciones miembro

[noexcept] QExplicitlySharedDataPointer::QExplicitlySharedDataPointer()

Crea un objeto `QExplicitlySharedDataPointer` inicializado con ` nullptr ` como puntero `d`.

[explicit noexcept] QExplicitlySharedDataPointer::QExplicitlySharedDataPointer(T *data)

Crea un objeto `QExplicitlySharedDataPointer` con el puntero `d` establecido en ` data ` e incrementa el recuento de referencias de ` data`.

[noexcept] template <typename X> QExplicitlySharedDataPointer::QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<X> &o)

Este constructor de copia se diferencia en que permite que ` o ` sea un tipo distinto de puntero a datos compartidos explícitamente, siempre que dicho tipo tenga un objeto de datos compartidos compatible.

Por defecto, el puntero d de ` o ` (de tipo ` \a X *`) se convierte implícitamente al tipo ` \a T *`; el resultado de esta conversión se establece como el puntero d de `this`, y se incrementa el recuento de referencias del objeto de datos compartido.

[noexcept] QExplicitlySharedDataPointer::QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T> &o)

Este constructor de copia estándar establece el puntero `d` de `this` en el puntero `d` de ` o ` e incrementa el recuento de referencias del objeto de datos compartido.

[noexcept] QExplicitlySharedDataPointer::QExplicitlySharedDataPointer(QExplicitlySharedDataPointer<T> &&o)

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

QExplicitlySharedDataPointer::~QExplicitlySharedDataPointer()

Disminuye el recuento de referencias del objeto de datos compartido. Si el recuento de referencias llega a 0, el objeto de datos compartido se elimina. A continuación , se destruye.

[protected] T *QExplicitlySharedDataPointer::clone()

Crea y devuelve una copia profunda de los datos actuales. La función ` detach()` invoca esta función cuando el recuento de referencias es mayor que 1, con el fin de crear la nueva copia. Esta función utiliza el operador `new` y llama al constructor de copia del tipo ` T`.

Consulta QSharedDataPointer<T>::clone() para obtener una explicación sobre cómo utilizarla.

[noexcept] const T *QExplicitlySharedDataPointer::constData() const

Devuelve un puntero const al objeto de datos compartido.

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

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

Devuelve un puntero al objeto de datos compartido.

void QExplicitlySharedDataPointer::detach()

Si el recuento de referencias del objeto de datos compartido es superior a 1, esta función crea una copia profunda del objeto de datos compartido y establece el puntero `d` de este último en la copia.

Dado que ` QExplicitlySharedDataPointer ` no realiza la copia automática en las operaciones de escritura, como sí lo hacen los miembros de ` QSharedDataPointer `, la función `detach()` no se invoca automáticamente en ninguna parte de las funciones miembro de esta clase. Si observas que estás llamando a `detach()` en todas partes de tu código, plantéate utilizar ` QSharedDataPointer ` en su lugar.

[noexcept, since 6.0] T *QExplicitlySharedDataPointer::get() const

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

Esta función se introdujo en Qt 6.0.

[noexcept, since 6.0] void QExplicitlySharedDataPointer::reset(T *ptr = nullptr)

Establece el puntero «d» de este objeto en ptr e incrementa el recuento de referencias de ptr si ptr no es nullptr. Se decrementa el recuento de referencias del antiguo objeto de datos compartidos y se elimina el objeto si el recuento de referencias llega a 0.

Esta función se introdujo en Qt 6.0.

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

Intercambia este puntero de datos compartido explícitamente con other. Esta operación es muy rápida y nunca falla.

[noexcept] T *QExplicitlySharedDataPointer::take()

Devuelve un puntero al objeto compartido y restablece `this` para que apunte a ` nullptr`. (Es decir, esta función establece el puntero `d` de `this` en ` nullptr`.)

Nota: El recuento de referencias del objeto devuelto no se reducirá. Esta función se puede utilizar junto con el constructor que toma un objeto de etiqueta ` QAdoptSharedDataTag ` para transferir el objeto de datos compartido sin operaciones atómicas intermedias.

[noexcept] QExplicitlySharedDataPointer::operator bool() const

Devuelve ` true ` si el puntero `d` de esta variable no es nulo.

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

Devuelve ` true ` si el puntero `d` de este objeto es ` nullptr`.

T &QExplicitlySharedDataPointer::operator*() const

Permite acceder a los miembros del objeto de datos compartido.

[noexcept] T *QExplicitlySharedDataPointer::operator->()

Permite acceder a los miembros del objeto de datos compartido.

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

Proporciona acceso de tipo «const» a los miembros del objeto de datos compartido.

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

Asigna « other » a esta instancia de « QExplicitlySharedDataPointer ». .

[noexcept] QExplicitlySharedDataPointer<T> &QExplicitlySharedDataPointer::operator=(T *o)

Establece el puntero d de este objeto en o e incrementa el recuento de referencias de o. Se decrementa el recuento de referencias del antiguo objeto de datos compartidos de este. Si el recuento de referencias del antiguo objeto de datos compartidos pasa a ser 0, dicho objeto se elimina.

[noexcept] QExplicitlySharedDataPointer<T> &QExplicitlySharedDataPointer::operator=(const QExplicitlySharedDataPointer<T> &o)

Establece el puntero `d` de este objeto en el puntero `d` de ` o ` e incrementa el recuento de referencias del objeto de datos compartidos. Se decrementa el recuento de referencias del antiguo objeto de datos compartidos de este objeto. Si el recuento de referencias del antiguo objeto de datos compartidos llega a 0, dicho objeto se elimina.

Elementos no miembros relacionados

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

Devuelve ` true ` si ` lhs ` y ` rhs ` no tienen el mismo puntero `d`.

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

Devuelve ` true ` si el puntero `d` de ` rhs ` no es ` lhs`.

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

Devuelve ` true ` si ` lhs ` y ` rhs ` tienen el mismo puntero `d`.

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

Devuelve ` true ` si el puntero `d` de ` rhs ` es ` lhs`.

© 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.