Réflexion Qt C++ avec copie et affectation

Question

Comme the QObject documentation et beaucoup d'autres expliquent, un QObject a une identité et cache ainsi son constructeur de copie et son opérateur d'affectation.

Cependant, je ne dérive pas de QObject pour sa fonction de propriétés dynamiques ou la fonction signaux/slots. Je veux seulement réflexion, ou la possibilité d'accéder à 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) 

Je ne peux donc pas copier Foo avec:

Foo a; 
Foo b; 
a = b; 

Quelle est la meilleure façon de permettre la copie et l'affectation dans ce cas? Ai-je absolument besoin d'écrire un constructeur de copie et un opérateur d'affectation? De quoi auraient-ils l'air? La réflexion fonctionnera-t-elle encore?

Answer 1

Si vous êtes intéressés seulement par réflexion pour

• le nom de classe,
• énumérations et drapeaux (Q_ENUMS, Q_FLAGS),
• info classe (Q_CLASSINFO),

vous pouvez utiliser Q_GADGET instead of Q_OBJECT:

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

qui va déclarer et définir Foo::staticMetaObject.

Answer 2

Je ne connais pas grand-chose à propos de qt, mais si le constructeur de copie n'est pas autorisé alors il devrait y avoir une raison à cela (ce qui est discuté dans le lien que vous avez posté). Vous pouvez changer votre conception pour ne pas l'avoir.

Encore si vous insistez alors memcpy peut être votre dernier recours. Je ne le recommande pas personnellement, parce que vous devez faire attention à la copie en profondeur, vtable etc qui ne sont pas toujours triviales.

Answer 3

Vous pouvez certainement implémenter à la fois un constructeur de copie et un opérateur d'affectation de copie dans votre classe dérivée, mais c'est probablement un signe de mauvaise conception. Prenez cet exemple:

#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; 
} 

Cela se compilera très bien. Cependant, comme prévu, lorsque vous exécutez le programme résultant, tout ce qui est imprimé est Derived copy constructor invoked!. Lorsque la classe de base déclare son constructeur de copie/opérateur d'affectation de copie comme privé, cela n'empêche pas les classes dérivées d'implémenter leurs propres versions. Il empêche simplement les classes dérivées d'appeler les versions de la classe de base.

Et c'est là que réside le problème: c'est toujours une bonne pratique de vous assurer de copier toutes les parties d'un objet, de sorte que vous avez en effet deux copies distinctes. Une partie de votre objet inclut les données appartenant à la classe de base. Vous devez donc toujours vous assurer d'appeler l'opérateur de copie/constructeur de copie de la classe de base pour vous assurer qu'une copie complète est effectuée. Mais ces données sont par nature non-copiables. Ainsi, il est impossible de copier toutes les parties de l'objet.

C'est à vous de choisir si vous voulez rester avec cette conception. Une chose importante à se demander est, est-ce que votre classe dérivée doit vraiment être copiable du tout? Si non, alors il n'y a pas de quoi s'inquiéter!