QSharedDataPointer Class

Descripción detallada

QSharedDataPointer<T> hace que escribir tus propias clases implícitamente compartidas sea fácil. QSharedDataPointer implementa el conteo de referencias a prueba de hilos, asegurando que añadir QSharedDataPointers a tus clases reentrantes no las hará no reentrantes.

La compartición implícita es utilizada por muchas clases Qt para combinar la velocidad y eficiencia de memoria de los punteros con la facilidad de uso de las clases. Vea la página de Clases Compartidas para más información.

Supongamos que quieres hacer una clase Employee implícitamente compartida. El procedimiento es:

• Defina la clase Employee para que tenga un único miembro de datos de tipo QSharedDataPointer<EmployeeData>.
• Defina la clase EmployeeData derivada de QSharedData para que contenga todos los miembros de datos que normalmente habría puesto en la clase Employee.

Para mostrar esto en la práctica, revisaremos el código fuente de la clase Employee compartida implícitamente. En el fichero 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, observe el único miembro de datos, un puntero d de tipo QSharedDataPointer<EmployeeData>. Todos los accesos a los datos del empleado deben pasar por el puntero d de operator->(). Para los accesos de escritura, operator->() llamará automáticamente a detach(), que crea una copia del objeto de datos compartidos si el recuento de referencias del objeto de datos compartidos es mayor que 1. Esto garantiza que las escrituras 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 entre bastidores. EmployeeData tiene un constructor por defecto, un constructor de copia y un destructor. Normalmente, las implementaciones triviales de estos son todo lo que se necesita en la clase de datos para una clase implícitamente compartida.

La implementación de los dos constructores de 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);
}

Nótese que la clase Employee también tiene definido un constructor de copia trivial, que 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í, porque la clase EmployeeData está incluida en el mismo fichero que la clase Employee (employee.h). Sin embargo, incluir la subclase privada de QSharedData en el mismo fichero que la clase pública que contiene el QSharedDataPointer no es típico. Normalmente, la idea es ocultar la subclase privada de QSharedData al usuario poniéndola en un fichero separado que no se incluiría en el fichero público. En este caso, normalmente pondríamos la clase EmployeeData en un fichero separado, que no se incluiría en employee.h. En su lugar, simplemente predeclararíamos la subclase privada EmployeeData en employee.h de esta forma:

class EmployeeData;

Si lo hubiéramos hecho así aquí, el constructor de copia mostrado sería necesario. Como el constructor de copia es trivial, es mejor incluirlo siempre.

Entre bastidores, QSharedDataPointer incrementa automáticamente la cuenta de referencias cada vez que un objeto Employee es copiado, asignado o pasado como parámetro. Disminuye la cuenta de referencias siempre que un objeto Employee es borrado o sale del ámbito. El objeto EmployeeData compartido se elimina automáticamente cuando el recuento de referencias llega a 0.

En una función miembro no-const de Employee, siempre que el puntero d es dereferenciado, QSharedDataPointer llama automáticamente a detach() para asegurar que la función opera en su propia copia de los datos.

void setId(int id) { d->id = id; }

void setName(const QString &name) { d->name = name; }

Tenga en cuenta que si detach() es llamado más de una vez en una función miembro debido a múltiples desreferencias del puntero d, detach() sólo creará una copia de los datos compartidos la primera vez que sea llamado, si es que lo hace, porque en la segunda y posteriores llamadas de detach(), el recuento de referencias será 1 de nuevo.

Pero observe que en el segundo constructor de Employee, que toma un ID de empleado y un nombre, se llama tanto a setId() como a setName(), pero no causan copia al escribir, porque la cuenta de referencias para el objeto EmployeeData recién construido acaba de ser puesta a 1.

En las funciones const de Employee, la desreferenciación del puntero d no provoca la llamada a detach().

int id() const { return d->id; }

QString name() const { return d->name; }

Observe que no hay necesidad de implementar un constructor de copia o un operador de asignación para la clase Employee, porque el constructor de copia y el operador de asignación proporcionados por el compilador C++ harán la copia superficial miembro por miembro requerida. El único miembro a copiar es el puntero d, que es un QSharedDataPointer, cuyo operator=() sólo incrementa la cuenta de referencias del objeto compartido EmployeeData.

Compartición implícita vs explícita

La compartición implícita puede no ser adecuada para la clase Employee. Consideremos un ejemplo simple que crea dos instancias de la clase Employee compartida implícitamente.

#include "employee.h"

int main()
{
    Employee e1(1001, "Albrecht Durer");
    Employee e2 = e1;
    e1.setName("Hans Holbein");
}

Después de crear el segundo empleado e2 y asignarle e1, tanto e1 como e2 hacen referencia a Albrecht Durer, empleado 1001. Ambos objetos Employee apuntan a la misma instancia de EmployeeData, que tiene la cuenta de referencia 2. A continuación, se llama a e1.setName("Hans Holbein") para cambiar el nombre del empleado, pero como el número de referencias es mayor que 1, se realiza una copia en escritura antes de cambiar el nombre. Ahora e1 y e2 apuntan a diferentes objetos EmployeeData. Tienen nombres diferentes, pero ambos tienen el ID 1001, que probablemente no es lo que quieres. Puedes, por supuesto, continuar con e1.setId(1002), si realmente quieres crear un segundo empleado único, pero si sólo quieres cambiar el nombre del empleado en todas partes, considera usar explicit sharing en la clase Employee en lugar de compartir implícitamente.

Si declara el puntero d en la clase Employee como QExplicitlySharedDataPointer<EmployeeData>, entonces se utiliza la compartición explícita y las operaciones de copia en escritura no se realizan automáticamente (es decir, no se llama a detach() en funciones no-const). En ese caso, después de 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 sólo hay un empleado con ID 1001.

En la documentación de las funciones miembro, el puntero d siempre se refiere al puntero interno al objeto de datos compartidos.

Optimizar el rendimiento para su uso en contenedores Qt

Debería considerar marcar su clase implícitamente compartida como un tipo movible utilizando la macro Q_DECLARE_TYPEINFO() si se parece a la clase Employee anterior y utiliza un QSharedDataPointer o QExplicitlySharedDataPointer como único miembro. Esto puede mejorar el rendimiento y la eficiencia de memoria al utilizar las clases contenedoras de Qt.