Le système des méta-objets

Le système de méta-objets de Qt fournit le mécanisme de signaux et de slots pour la communication entre objets, les informations de type à l'exécution et le système de propriétés dynamiques.

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

1. La classe ` QObject ` sert de classe de base aux objets pouvant tirer parti du système de méta-objets.
2. La macro ` Q_OBJECT ` sert à activer les fonctionnalités des méta-objets, telles que les propriétés dynamiques, les signaux et les slots.
3. La fonction Meta-Object Compiler (moc) fournit à chaque sous-classe d’ QObject le code nécessaire à la mise en œuvre des fonctionnalités 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 génère un autre fichier source C++ contenant le code méta-objet pour chacune de ces classes. Ce fichier source généré est soit intégré par l’opérateur « #include » dans le fichier source de la classe, soit, plus couramment, compilé et lié à l’implémentation de la classe.

Outre le mécanisme de signaux et de slots permettant la communication entre les objets (raison principale de l’introduction du système), le code méta-objet offre les fonctionnalités supplémentaires suivantes :

• QObject::metaObject() renvoie l’ meta-object e associée à la classe.
• QMetaObject::className() renvoie le nom de la classe sous forme de chaîne de caractères lors de l’exécution, sans nécessiter la prise en charge des informations de type à l’exécution (RTTI) par le compilateur C++.
• QObject::inheritsLa fonction () indique si un objet est une instance d’une classe héritant d’une classe spécifiée au sein de l’arborescence d’héritage d’ QObject.
• QObject::tr() traduit les chaînes de caractères à des fins d’internationalisation.
• QObject::setProperty() et QObject::property() définissent et récupèrent dynamiquement des propriétés par leur nom.
• QMetaObject::newInstance() construit une nouvelle instance de la classe.

Il est également possible d’effectuer des transtypages dynamiques à l’aide de ` qobject_cast()` sur les classes ` QObject `. La fonction ` qobject_cast()` se comporte de manière similaire à la fonction standard C++ ` dynamic_cast()`, avec l’avantage de ne pas nécessiter de prise en charge RTTI et de fonctionner au-delà des limites des bibliothèques dynamiques. Elle tente de convertir son argument vers le type de pointeur spécifié entre crochets angulaires, en renvoyant un pointeur non nul si l’objet est du type correct (déterminé à l’exécution), ou nullptr si le type de l’objet est incompatible.

Par exemple, supposons qu’ MyWidget hérite de QWidget et soit déclarée 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 ` ; nous pouvons donc la convertir de manière appropriée :

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

La conversion de QObject en QWidget aboutit, car l’objet est en réalité un MyWidget, qui est une sous-classe de QWidget. Comme nous savons que obj est un MyWidget, nous pouvons également le convertir en MyWidget *:

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

La conversion vers ` MyWidget ` réussit car ` qobject_cast()` ne fait aucune distinction entre les types Qt intégrés et les types personnalisés.

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

En revanche, la conversion vers ` QLabel` échoue. Le pointeur est alors défini sur ` nullptr`. Cela permet de traiter différemment les objets de types différents lors de 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 et slots, ni les autres fonctionnalités 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 de ` QObject ` sans code méta est équivalente à son ancêtre le plus proche doté d’un code méta-objet. Cela signifie par exemple que ` QMetaObject::className()` ne renverra pas le nom réel de votre classe, mais le nom de 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.