C++ Qt Reflection with Copy and Assignment

Question

Como the QObject documentation y muchos otros explican, un QObject tiene una identidad y oculta su copia de constructor y operador de asignación.

Sin embargo, no estoy derivando de QObject por su característica de propiedades dinámicas o la característica de señales/ranuras. Solo quiero reflexión, o la posibilidad de acceder a Foo::staticMetaObject.

class Foo : public QObject { 
    Q_OBJECT 
    Q_ENUMS(Color) 
public: 
    enum Color { Blue, Red, Pink }; 
private: 
    Color color; 
}; 

Q_DECLARE_METATYPE(Foo::Color) 

Entonces no puedo copiar Foo con:

Foo a; 
Foo b; 
a = b; 

¿Cuál es la mejor manera de permitir la copia y la asignación en este caso? ¿Debo absolutamente escribir un constructor de copias y un operador de asignación? ¿Cómo se verían? ¿La reflexión todavía funcionará?

Answer 1

Si sólo está interesado en que la reflexión de

• el nombre de clase,
• enumeraciones y banderas (Q_ENUMS, Q_FLAGS),
• información de clase (Q_CLASSINFO),

puede usar Q_GADGET instead of Q_OBJECT:

class Foo { 
    Q_GADGET 
    Q_ENUMS(Color) 
public: 
    enum Color { Blue, Red, Pink }; 
private: 
    Color color; 
}; 

que declarará y definirá Foo::staticMetaObject.

Answer 2

No sé mucho sobre qt, pero si el constructor de copia no está permitido, entonces debe haber una razón para ello (que se explica en el enlace que publicó). Puede cambiar su diseño para no tenerlo.

Aún si insiste, entonces memcpy puede ser su último recurso. No lo recomiendo personalmente, porque tienes que preocuparte por la copia profunda, vtable, etc., que no siempre son triviales.

Answer 3

Sin duda puede implementar tanto un constructor de copia como un operador de asignación de copia en su clase derivada, pero es probable que sea un signo de mal diseño. Tome este ejemplo:

#include <iostream> 

class Base { 
public: 
    Base() {} 

private: 
    Base(const Base& other) { 
     std::cout << "Base copy constructor invoked!" << std::endl; 
    } 
}; 

class Derived : public Base { 
public: 
    Derived() {} 

    Derived(const Derived& other) { 
     std::cout << "Derived copy constructor invoked!" << std::endl; 
    } 
}; 

int main(int argc, char** argv) { 
    Derived a; 
    Derived b = a; 

    return 0; 
} 

Esto compilará muy bien. Sin embargo, como se esperaba, cuando ejecuta el programa resultante, todo lo que se imprime es Derived copy constructor invoked!. Cuando la clase base declara su operador de asignación de copia/constructor como privado, eso no impide que las clases derivadas implementen sus propias versiones. Simplemente impide que las clases derivadas invoquen las versiones de clase base.

Y ahí radica el problema: siempre es una buena práctica asegurarse de copiar todas las partes de un objeto, de modo que de hecho tenga dos copias distintas. Parte de su objeto incluye los datos propiedad de la clase base, por lo que siempre debe asegurarse de invocar el operador de asignación de copia/constructor de copia de la clase base para asegurarse de que se realiza una copia completa. Pero esos datos son, por diseño, no copiables. Por lo tanto, es imposible copiar todas las partes del objeto.

Depende de usted si desea seguir con este diseño. Una cosa importante que debes hacerte es, ¿tu clase derivada realmente necesita ser copiable? Si no, ¡entonces no hay nada de qué preocuparse!