Le système des méta-objets

Le système de méta-objets de Qt fournit les signaux et les mécanismes de fentes pour la communication inter-objets, les informations de type d'exécution et le système de propriétés dynamiques.

Le système de méta-objets est basé sur trois éléments :

1. La classe QObject fournit une classe de base pour les objets qui peuvent tirer parti du système de méta-objets.
2. La macro Q_OBJECT est utilisée pour activer les fonctionnalités des méta-objets, telles que les propriétés dynamiques, les signaux et les slots.
3. La macro Meta-Object Compiler (moc) fournit à chaque sous-classe QObject le code nécessaire à la mise en œuvre des fonctionnalités des méta-objets.

L'outil moc lit un fichier source C++. S'il trouve une ou plusieurs déclarations de classe contenant la macro Q_OBJECT, il produit un autre fichier source C++ contenant le code du méta-objet pour chacune de ces classes. Ce fichier source généré est soit #include'd dans le fichier source de la classe, soit, plus généralement, compilé et lié à l'implémentation de la classe.

En plus de fournir le mécanisme de signaux et de fentes pour la communication entre les objets (la raison principale de l'introduction du système), le code des méta-objets fournit les caractéristiques supplémentaires suivantes :

• QObject::metaObject() renvoie l'adresse meta-object associée à la classe.
• QMetaObject::classNameLa fonction () renvoie le nom de la classe sous forme de chaîne de caractères au moment de l'exécution, sans nécessiter la prise en charge de l'information sur le type d'exécution (RTTI) par le compilateur C++.
• QObject::inheritsLa fonction () indique si un objet est une instance d'une classe qui hérite d'une classe spécifiée dans l'arbre d'héritage QObject.
• QObject::tr() traduit les chaînes de caractères pour l'internationalisation.
• QObject::setProperty() et QObject::property() définissent et obtiennent dynamiquement des propriétés par leur nom.
• QMetaObject::newInstance() construit une nouvelle instance de la classe.

Il est également possible d'effectuer des transformations dynamiques en utilisant qobject_cast() sur les classes QObject. La fonction qobject_cast() se comporte de manière similaire à la fonction C++ standard dynamic_cast(), avec l'avantage de ne pas nécessiter de support RTTI et de fonctionner à travers les limites des bibliothèques dynamiques. Elle tente de convertir son argument dans le type de pointeur spécifié entre crochets, en renvoyant un pointeur non nul si l'objet est du bon type (déterminé à l'exécution), ou nullptr si le type de l'objet est incompatible.

Par exemple, supposons que MyWidget hérite de QWidget et soit déclaré avec la macro Q_OBJECT:

    QObject *obj = new MyWidget;

La variable obj, de type QObject *, fait en réalité référence à un objet MyWidget, et nous pouvons donc la caster de manière appropriée :

    QWidget *widget = qobject_cast<QWidget *>(obj);

Le cast de QObject vers QWidget est réussi, car l'objet est en fait un MyWidget, qui est une sous-classe de QWidget. Puisque nous savons que obj est un MyWidget, nous pouvons également le cast vers MyWidget *:

    MyWidget *myWidget = qobject_cast<MyWidget *>(obj);

Le cast vers MyWidget est réussi car qobject_cast() ne fait pas de distinction entre les types Qt intégrés et les types personnalisés.

    QLabel *label = qobject_cast<QLabel *>(obj);
    // label is nullptr

Le cast vers QLabel, en revanche, échoue. Le pointeur prend alors la valeur nullptr, ce qui permet de traiter les objets de différents types différemment à l'exécution, en fonction de leur type :

    if (QLabel *label = qobject_cast<QLabel *>(obj)) {
        label->setText(tr("Ping"));
    } else if (QPushButton *button = qobject_cast<QPushButton *>(obj)) {
        button->setText(tr("Pong!"));
    }

Bien qu'il soit possible d'utiliser QObject comme classe de base sans la macro Q_OBJECT et sans code méta-objet, ni les signaux, ni les fentes, ni les autres caractéristiques décrites ici ne seront disponibles si la macro Q_OBJECT n'est pas utilisée. Du point de vue du système de méta-objets, une sous-classe QObject sans code méta est équivalente à son ancêtre le plus proche avec un code méta-objet. Cela signifie, par exemple, que QMetaObject::className() ne renverra pas le nom actuel de votre classe, mais le nom de la classe de cet ancêtre.

Par conséquent, nous recommandons vivement que toutes les sous-classes de QObject utilisent la macro Q_OBJECT, qu'elles utilisent ou non des signaux, des slots et des propriétés.