QSharedDataPointer Class
template <typename T> class QSharedDataPointerLa clase `QSharedDataPointer` representa un puntero a un objeto compartido de forma implícita. Más información...
| Cabecera: | #include <QSharedDataPointer> |
| 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 QSharedDataPointer
| Categoría | Tipos comparables |
|---|---|
| strong | QSharedDataPointer |
| strong | T* y std::nullptr_t. |
Tipos públicos
Funciones públicas
| QSharedDataPointer() | |
| QSharedDataPointer(T *data) | |
(since 6.0) | QSharedDataPointer(T *data, QAdoptSharedDataTag) |
| QSharedDataPointer(const QSharedDataPointer<T> &o) | |
| QSharedDataPointer(QSharedDataPointer<T> &&o) | |
| ~QSharedDataPointer() | |
| const T * | constData() const |
| T * | data() |
| const T * | data() const |
| void | detach() |
(since 6.0) T * | get() |
(since 6.0) const T * | get() const |
(since 6.0) void | reset(T *ptr = nullptr) |
| void | swap(QSharedDataPointer<T> &other) |
(since 6.0) T * | take() |
| operator T *() | |
| operator const T *() const | |
| bool | operator!() const |
| T & | operator*() |
| const T & | operator*() const |
| T * | operator->() |
| const T * | operator->() const |
| QSharedDataPointer<T> & | operator=(QSharedDataPointer<T> &&other) |
| QSharedDataPointer<T> & | operator=(T *o) |
| QSharedDataPointer<T> & | operator=(const QSharedDataPointer<T> &o) |
Funciones protegidas
| T * | clone() |
Elementos no miembros relacionados
| bool | operator!=(T *const &lhs, const QSharedDataPointer<T> &rhs) |
| bool | operator!=(const QSharedDataPointer<T> &lhs, const QSharedDataPointer<T> &rhs) |
| bool | operator==(T *const &lhs, const QSharedDataPointer<T> &rhs) |
| bool | operator==(const QSharedDataPointer<T> &lhs, const QSharedDataPointer<T> &rhs) |
Descripción detallada
`QSharedDataPointer` 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`.
QSharedDataPointer<T> facilita la creación de tus propias clases compartidas implícitamente. QSharedDataPointer implementa un recuento de referencias seguro para subprocesos, lo que garantiza que añadir QSharedDataPointers a tus clases reentrantes no las convierta en no reentrantes.
Muchas clases de Qt utilizanel uso compartido implícito para combinar la velocidad y la eficiencia en el uso de la memoria de los punteros con la facilidad de uso de las clases. Consulta la página Clases compartidas para obtener más información.
Supongamos que quieres hacer que una clase ` Employee ` sea implícitamente compartida. El procedimiento es el siguiente:
- Define la clase `
Employee` para que tenga un único miembro de datos de tipo `QSharedDataPointer<EmployeeData>`. - Define la clase «
EmployeeData», derivada de « QSharedData », para que contenga todos los miembros de datos que normalmente habrías incluido en la clase «Employee».
Para ilustrarlo en la práctica, revisamos el código fuente de la clase Employee, que se comparte de forma implícita. En el archivo de cabecera definimos las dos clases Employee y EmployeeData.
#include <QSharedData>
#include <QSharedDataPointer>
#include <QString>
class EmployeeData : public QSharedData
{
public:
EmployeeData() : id(-1) {}
EmployeeData(const EmployeeData &other)
: QSharedData(other), id(other.id), name(other.name) {}
~EmployeeData() = default;
int id;
QString name;
};
class Employee
{
public:
Employee() { d = new EmployeeData; }
Employee(int id, const QString &name) {
d = new EmployeeData;
setId(id);
setName(name);
}
Employee(const Employee &other) = default;
Employee &operator=(const Employee &other) = default;
Employee(Employee &&other) = default;
Employee &operator=(Employee &&other) = default;
~Employee() = default;
void setId(int id) { d->id = id; }
void setName(const QString &name) { d->name = name; }
int id() const { return d->id; }
QString name() const { return d->name; }
private:
QSharedDataPointer<EmployeeData> d;
};En la clase ` Employee`, fíjate en el único miembro de datos: un puntero `d` de tipo ` QSharedDataPointer<EmployeeData>`. Todos los accesos a los datos de los empleados deben realizarse a través de la clase ` operator->()` del puntero `d`. Para los accesos de escritura, ` operator->() ` llamará automáticamente a ` detach()`, que crea una copia del objeto de datos compartido si el recuento de referencias de dicho objeto es mayor que 1. Esto garantiza que las operaciones de escritura en un objeto Employee no afecten a ningún otro objeto Employee que comparta el mismo objeto EmployeeData.
La clase EmployeeData hereda de QSharedData, que proporciona el contador de referencias en segundo plano. EmployeeData tiene un constructor por defecto, un constructor de copia y un destructor. Normalmente, basta con implementaciones triviales de estos constructores y destructores en la clase de datos para una clase compartida implícitamente.
La implementación de los dos constructores para la clase ` Employee ` también es sencilla. Ambos crean una nueva instancia de ` EmployeeData ` y la asignan al puntero `d`.
Employee() { d = new EmployeeData; }
Employee(int id, const QString &name) {
d = new EmployeeData;
setId(id);
setName(name);
}Cabe señalar que la clase ` Employee ` también tiene definido un constructor de copia trivial, lo cual no es estrictamente necesario en este caso.
Employee(const Employee &other) = default;
Employee &operator=(const Employee &other) = default;
Employee(Employee &&other) = default;
Employee &operator=(Employee &&other) = default;
~Employee() = default;El constructor de copia no es estrictamente necesario aquí, ya que la clase EmployeeData está incluida en el mismo archivo que la clase Employee (employee.h). Sin embargo, incluir la subclase privada de QSharedData en el mismo archivo que la clase pública que contiene el QSharedDataPointer no es lo habitual. Normalmente, la idea es ocultar al usuario la subclase privada de QSharedData colocándola en un archivo independiente que no se incluiría en el archivo público. En este caso, lo habitual sería colocar la clase EmployeeData en un archivo independiente, que no se incluiría en employee.h. En su lugar, simplemente predeclararíamos la subclase privada EmployeeData en employee.h de esta manera:
class EmployeeData;Si lo hubiéramos hecho así aquí, el constructor de copia que se muestra sería obligatorio. Dado que el constructor de copia es trivial, más vale incluirlo siempre.
Entre bastidores, `QSharedDataPointer` incrementa automáticamente el recuento de referencias cada vez que se copia, se asigna o se pasa como parámetro un objeto ` Employee `. Decrementa el recuento de referencias cada vez que se elimina un objeto ` Employee ` o este sale del ámbito. El objeto compartido ` EmployeeData ` se elimina automáticamente cuando el recuento de referencias llega a 0.
En una función miembro no constante de ` Employee`, cada vez que se desreferencia el puntero `d`, `QSharedDataPointer` llama automáticamente a ` detach()` para garantizar que la función opera sobre su propia copia de los datos.
void setId(int id) { d->id = id; }
void setName(const QString &name) { d->name = name; }Ten en cuenta que, si se llama a ` detach()` más de una vez en una función miembro debido a múltiples desreferencias del puntero `d`, ` detach()` solo creará una copia de los datos compartidos la primera vez que se llame, si es que la crea, ya que en la segunda llamada y en las siguientes a ` detach()`, el recuento de referencias volverá a ser 1.
Pero hay que tener en cuenta que en el segundo constructor de Employee, que toma un ID de empleado y un nombre, se llaman tanto setId() como setName(), pero no provocan una copia al escribir, ya que el recuento de referencias del objeto EmployeeData recién creado acaba de establecerse en 1.
En las funciones miembro const de Employee, la desreferenciación del puntero d no provoca que se llame a detach().
int id() const { return d->id; }
QString name() const { return d->name; }Obsérvese que no es necesario implementar un constructor de copia ni un operador de asignación para la clase Employee, ya que el constructor de copia y el operador de asignación proporcionados por el compilador de C++ realizarán la copia superficial miembro por miembro necesaria. El único miembro que hay que copiar es el puntero d, que es un QSharedDataPointer, cuyo operator=() simplemente incrementa el recuento de referencias del objeto compartido EmployeeData.
Compartición implícita frente a explícita
Es posible que el uso compartido implícito no sea adecuado para la clase ` Employee `. Consideremos un ejemplo sencillo en el que se crean dos instancias de la clase ` Employee `, que se comparte de forma implícita.
#include "employee.h"
int main()
{
Employee e1(1001, "Albrecht Durer");
Employee e2 = e1;
e1.setName("Hans Holbein");
}Una vez creado el segundo empleado e2 y asignado e1 a él, tanto e1 como e2 hacen referencia a Albrecht Durer, el empleado 1001. Ambos objetos Employee apuntan a la misma instancia de EmployeeData, que tiene un recuento de referencias de 2. A continuación, se llama a e1.setName("Hans Holbein") para cambiar el nombre del empleado, pero como el recuento de referencias es mayor que 1, se realiza una copia en escritura antes de cambiar el nombre. Ahora, e1 y e2 apuntan a objetos EmployeeData diferentes. Tienen nombres distintos, pero ambos tienen el ID 1001, lo que probablemente no es lo que quieres. Por supuesto, puedes seguir adelante con e1.setId(1002) si realmente pretendes crear un segundo empleado único, pero si solo quieres cambiar el nombre del empleado en todas partes, plantéate utilizar explicit sharing en la clase Employee en lugar del uso compartido implícito.
Si declaras el puntero d de la clase Employee como QExplicitlySharedDataPointer<EmployeeData>, se utilizará el uso compartido explícito y las operaciones de «copia al escribir» no se realizarán automáticamente (es decir, detach() no se llamará en funciones no const). En ese caso, tras e1.setName("Hans Holbein"), el nombre del empleado ha cambiado, pero tanto e1 como e2 siguen haciendo referencia a la misma instancia de EmployeeData, por lo que solo hay un empleado con el ID 1001.
En la documentación de las funciones miembro, el puntero d siempre hace referencia al puntero interno al objeto de datos compartido.
Optimizar el rendimiento para su uso en contenedores de Qt
Deberías considerar marcar tu clase compartida implícitamente como un tipo movible utilizando la macro ` Q_DECLARE_TYPEINFO()` si se asemeja a la clase ` Employee ` anterior y utiliza un `QSharedDataPointer` o un ` QExplicitlySharedDataPointer ` como único miembro. Esto puede mejorar el rendimiento y la eficiencia de la memoria al utilizar las clases contenedoras de Qt.
Véase también QSharedData, QExplicitlySharedDataPointer, QScopedPointer y QSharedPointer.
Documentación sobre los tipos de miembros
QSharedDataPointer::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] QSharedDataPointer::QSharedDataPointer()
Crea un QSharedDataPointer inicializado con un puntero` nullptr ` como ` d`.
[explicit noexcept] QSharedDataPointer::QSharedDataPointer(T *data)
Crea un objeto `QSharedDataPointer` con el puntero `d` establecido en ` data ` e incrementa el recuento de referencias de ` data`.
[noexcept, since 6.0] QSharedDataPointer::QSharedDataPointer(T *data, QAdoptSharedDataTag)
Crea un `QSharedDataPointer` con el puntero `d` establecido en ` data`. El contador de referencias de ` data` no se incrementa; esto permite adoptar punteros obtenidos mediante ` take()`.
Esta función se introdujo en Qt 6.0.
Véase también ` take()`.
[noexcept] QSharedDataPointer::QSharedDataPointer(const QSharedDataPointer<T> &o)
Establece el puntero `d` de esta variable en el puntero `d` de ` o ` e incrementa el recuento de referencias del objeto de datos compartido.
[noexcept] QSharedDataPointer::QSharedDataPointer(QSharedDataPointer<T> &&o)
Crea una instancia de `QSharedDataPointer` mediante la construcción por movimiento, de modo que apunte al mismo objeto al que apuntaba ` o `.
QSharedDataPointer::~QSharedDataPointer()
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, este se destruye.
[protected] T *QSharedDataPointer::clone()
Crea y devuelve una copia profunda de los datos actuales. Esta función es invocada por ` detach()` 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`.
Esta función se proporciona para que puedas admitir «constructores de copia virtuales» para tus propios tipos. Para ello, debes declarar una especialización de plantilla de esta función para tu propio tipo, como en el ejemplo siguiente:
template<>
EmployeeData *QSharedDataPointer<EmployeeData>::clone()
{
return d->clone();
}En el ejemplo anterior, la especialización de plantilla para la función clone() llama a la función virtual EmployeeData::clone(). Una clase derivada de EmployeeData podría sobrescribir esa función y devolver el tipo polimórfico adecuado.
[noexcept] const T *QSharedDataPointer::constData() const
Devuelve un puntero const al objeto de datos compartido. Esta función no llama a detach().
Véase también ` data()`.
T *QSharedDataPointer::data()
Devuelve un puntero al objeto de datos compartido. Esta función llama a detach().
Véase también constData().
[noexcept] const T *QSharedDataPointer::data() const
Devuelve un puntero al objeto de datos compartido. Esta función no llama a ` detach()`.
void QSharedDataPointer::detach()
Si el recuento de referencias del objeto de datos compartido es mayor que 1, esta función crea una copia profunda del objeto de datos compartido y asigna el puntero `d` de este a la copia.
Esta función es llamada automáticamente por las funciones miembro no const de ` QSharedDataPointer ` si se requiere la copia en escritura. No es necesario que la llames tú mismo.
[since 6.0] T *QSharedDataPointer::get()
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, since 6.0] const T *QSharedDataPointer::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 QSharedDataPointer::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 ». El recuento de referencias del antiguo objeto de datos compartidos se decrementa, y el objeto se elimina si el recuento de referencias llega a 0.
Esta función se introdujo en Qt 6.0.
[noexcept] void QSharedDataPointer::swap(QSharedDataPointer<T> &other)
Intercambia este puntero de datos compartido con other. Esta operación es muy rápida y nunca falla.
[noexcept, since 6.0] T *QSharedDataPointer::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» para que apunte a « nullptr ».)
Nota: El recuento de referencias del objeto devuelto no se reducirá. Esta función puede utilizarse junto con el constructor que admite un objeto de etiqueta ` QAdoptSharedDataTag ` para transferir el objeto de datos compartido sin operaciones atómicas intermedias.
Esta función se introdujo en Qt 6.0.
QSharedDataPointer::operator T *()
Devuelve un puntero al objeto de datos compartido. Esta función llama a detach().
Véanse también data() y constData().
[noexcept] QSharedDataPointer::operator const T *() const
Devuelve un puntero al objeto de datos compartido. Esta función no llama a ` detach()`.
[noexcept] bool QSharedDataPointer::operator!() const
Devuelve ` true ` si el puntero `d` de este objeto es ` nullptr`.
T &QSharedDataPointer::operator*()
Permite acceder a los miembros del objeto de datos compartido. Esta función llama a la función « detach()».
const T &QSharedDataPointer::operator*() const
Proporciona acceso de tipo «const» a los miembros del objeto de datos compartido. Esta función no llama a ` detach()`.
T *QSharedDataPointer::operator->()
Permite acceder a los miembros del objeto de datos compartido. Esta función llama a la función « detach()».
[noexcept] const T *QSharedDataPointer::operator->() const
Proporciona acceso de tipo «const» a los miembros del objeto de datos compartido. Esta función no llama a ` detach()`.
[noexcept] QSharedDataPointer<T> &QSharedDataPointer::operator=(QSharedDataPointer<T> &&other)
Asigna « other » a esta instancia de « QSharedDataPointer ».
[noexcept] QSharedDataPointer<T> &QSharedDataPointer::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 objeto. Si el recuento de referencias del antiguo objeto de datos compartidos llega a 0, dicho objeto se elimina.
[noexcept] QSharedDataPointer<T> &QSharedDataPointer::operator=(const QSharedDataPointer<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!=(T *const &lhs, const QSharedDataPointer<T> &rhs)
Devuelve ` true ` si el puntero `d` de ` rhs ` no es ` lhs`. Puntero `d`. Esta función no llama a ` detach()`.
[noexcept] bool operator!=(const QSharedDataPointer<T> &lhs, const QSharedDataPointer<T> &rhs)
Devuelve ` true ` si ` lhs ` y ` rhs ` no tienen el mismo puntero `d`. Esta función no llama a ` detach()`.
[noexcept] bool operator==(T *const &lhs, const QSharedDataPointer<T> &rhs)
Devuelve ` true ` si el puntero `d` de ` rhs ` es ` lhs`. Esta función no llama a ` detach()`.
[noexcept] bool operator==(const QSharedDataPointer<T> &lhs, const QSharedDataPointer<T> &rhs)
Devuelve ` true ` si ` lhs ` y ` rhs ` tienen el mismo puntero `d`. Esta función no llama a ` detach()`.
© 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.