Epsilon_GT_v8_Mise en page 1 06/05/2014 10:24 Page 20 Le livre a été conçu pour entrer progressivement dans les profondeurs de Qt. Étape par étape vous comprendrez le modèle objet de Qt et la programmation événementielle pour structurer vos applications et atteindre très vite des objectifs complexes. Lorsque vous maîtriserez ces fondamentaux vous approfondirez les bibliothèques de composants en parcourant tous les modules de Qt : le module réseau (QtNetwork), le module SQL (QtSql), les modules graphiques 2D et 3D (QtGui), les modules de composants d'interface graphique et multimédia (QtWidgets et QtMultimedia). Les derniers chapitres vous permettront de rendre concret cet ensemble en l'appliquant au travail quotidien d'un développeur sérieux : la testabilité du code, qui est une réelle problématique d'entreprise, et le packaging des applications, pour leur diffusion sur tous les systèmes d'exploitation. Les concepts présentés dans cet ouvrage sont illustrés par des exemples dont le code source est téléchargeable sur le site www.editions-eni.fr. Les chapitres du livre Introduction L environnement de développement Le modèle «event-driven» Anatomie d une application QtCore et fondations QtNetwork QtSql QtGui QtWidgets QtMultimedia Les modules graphiques et web QtTest : qualité du code Traduction d une application Publication d une application Techniques d optimisation ISSN 1960-3444 ISBN 978-2-7460-8921-1 9 782746 089211 54 Plus d informations : Tristan ISRAËL est développeur (Java, C, C++, Objective-C) depuis de nombreuses années et spécialisé sur Qt depuis l année 2007. Aujourd hui il développe également en Qt dans le cadre de ses missions de consulting ou pour des produits commercialisés sur les différents Stores. Titulaire des trois certifications Qt (Essentials, Widget UI et Core C++), il partage dans les pages de ce livre sa passion pour Qt qui lui permet de concilier le plaisir d'utiliser les technologies C avec le respect de la qualité fonctionnelle et ergonomique des applications qu il crée. Sur www.editions-eni.fr : b Code source d exemples autour des différents modules Qt. Ce livre sur Qt 5 s adresse aux professionnels de l informatique, développeurs débutants ou plus avancés, souhaitant maîtriser cet outil pour écrire du code de qualité et le tester, pour packager des applications et les distribuer sur les différents systèmes d exploitation pour PC, pour améliorer les performances des applications et satisfaire au mieux les exigences des utilisateurs. Pour tirer pleinement parti de ce livre, les lecteurs devront posséder des connaissances suffisantes en C++. Maîtrisez Qt 5 Guide de développement d applications professionnelles Téléchargement www.editions-eni.fr.fr Tristan ISRAËL
Table des matières 1 Les éléments à télécharger sont disponibles à l'adresse suivante : http://www.editions-eni.fr Saisissez la référence ENI de l'ouvrage EP5QT dans la zone de recherche et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement. Chapitre 1 Introduction 1. Objectifs et méthode...................................... 15 2. Glossaire................................................ 16 3. Qt, qu'est-ce?............................................ 18 3.1 Histoire............................................. 19 3.2 Compatibilité........................................ 20 3.3 Notoriété............................................ 21 3.4 Bibliothèque ou framework?............................ 21 3.5 Documentation....................................... 21 3.6 Que peut-on faire avec Qt?............................. 22 3.7 Modèles de conception................................. 23 3.8 Modèle objet......................................... 23 3.9 Plugins Qt........................................... 24 4. Retour sur C++.......................................... 25 4.1 Pointeurs et références................................. 26 4.1.1 Pointeurs C..................................... 26 4.1.2 Références...................................... 28 4.2 Copie d'objets........................................ 30 4.2.1 Copie superficielle (shallow copy)................... 30 4.2.2 Copie en profondeur (deep copy)................... 32 4.2.3 Copie paresseuse (lazy copy)....................... 34 4.2.4 Partage implicite................................. 37 4.3 Types primitifs....................................... 39
2 4.4 Gestion de la mémoire................................. 40 4.4.1 Cycle de vie..................................... 41 4.4.2 Structures de données............................ 41 4.5 STL, Boost et Qt...................................... 42 4.6 Réentrance.......................................... 44 4.7 Exceptions........................................... 45 Chapitre 2 L'environnement de développement 1. Objectifs................................................ 47 2. Licence commerciale ou libre?.............................. 47 2.1 Propriété intellectuelle et GPL........................... 48 2.2 Diffusion de l'application............................... 48 3. Choisir judicieusement son compilateur....................... 49 3.1 Monoplateforme ou multiplateforme?................... 49 3.2 Maintenabilité du code................................ 52 4. Installer l'environnement de développement................... 53 4.1 Le compilateur....................................... 53 4.2 Qt Creator........................................... 54 4.3 Intégrer un autre environnement de compilation........... 57 5. Maintenir à jour son environnement......................... 61 5.1 Profiter des dernières nouveautés........................ 63 5.2 Gérer le cycle de vie de son application.................... 65 6. Utiliser Qt Creator........................................ 66 6.1 Organisation des projets............................... 66 6.2 Fenêtre principale..................................... 67 6.2.1 Boutons d'accès aux modules....................... 68 6.2.2 Boutons de compilation et d'exécution............... 68 6.2.3 Onglets de journaux.............................. 70
Table des matières 3 6.2.4 Onglets de contenus additionnels................... 72 6.2.5 Sessions récentes................................. 72 6.2.6 Projets récents................................... 72 6.3 Module d'édition...................................... 73 6.4 Module de conception d'interfaces graphiques.............. 73 6.5 Module de débogage................................... 74 6.6 Module de configuration de projet....................... 76 6.7 Module de profilage................................... 77 6.8 Paramétrage.......................................... 77 Chapitre 3 Le modèle «event-driven» 1. Objectifs................................................ 79 2. Pourquoi Qt est-il orienté événements?....................... 79 3. La notion de flux.......................................... 81 4. La run-loop.............................................. 86 5. La programmation asynchrone.............................. 88 6. Avantages et inconvénients................................. 90 7. Gestion des ressources et performances....................... 91 Chapitre 4 Anatomie d'une application 1. Objectifs................................................ 93 2. L'humain................................................ 94 2.1 Les différents types d'applications........................ 94 2.2 Contenu d'un projet Qt................................ 95 2.3 Création d'une application............................. 95 2.3.1 En ligne de commande............................ 95 2.3.2 Avec Qt Creator................................. 99
4 2.4 Le fichier projet.pro.................................. 102 2.4.1 Les directives de projet........................... 103 2.4.2 Les directives de chemins......................... 103 2.4.3 Les directives de précompilation................... 104 3. La machine............................................. 105 3.1 Les commandes externes.............................. 105 3.2 La phase de compilation............................... 105 Chapitre 5 QtCore et fondations 1. Objectifs............................................... 107 2. Intégration et interactions................................. 107 3. Découverte de QtCore.................................... 108 3.1 Principes de conception............................... 108 3.2 La classe QObject.................................... 109 3.2.1 Prototype...................................... 109 3.2.2 Copie......................................... 110 3.2.3 Internationalisation............................. 111 3.3 Métaclasses......................................... 111 3.4 La classe QVariant................................... 113 3.5 Propriétés Qt........................................ 114 3.6 Instanciation d'objets................................. 116 3.7 Votre modèle objet................................... 121 3.8 Signaux et slots...................................... 123 3.8.1 Le signal....................................... 124 3.8.2 Le slot........................................ 124 3.8.3 La connexion................................... 125 3.8.4 Différents types de connexion..................... 127 3.8.5 L'appel........................................ 129 3.8.6 Éléments particuliers............................ 131
Table des matières 5 3.9 Appel asynchrone d'une fonction....................... 135 3.9.1 L'émission de signaux............................ 136 3.9.2 L'utilisation d'un timer........................... 136 3.9.3 La fonction invokemethod....................... 137 4. Rendre ses algorithmes asynchrones......................... 137 4.1 Effectuer une boucle.................................. 138 4.2 Faire une pause dans le programme...................... 141 4.3 Synchroniser des objets............................... 141 5. Créer et piloter des threads................................ 146 5.1 Paralléliser des tâches................................. 147 5.1.1 Les threads pilotés.............................. 147 5.1.2 Un exemple.................................... 150 5.1.3 Les tâches simples............................... 152 5.1.4 Lancer une tâche asynchrone...................... 155 5.2 Synchronisation par blocage et protection................ 156 5.3 Synchronisation par notification........................ 158 6. Les pointeurs............................................ 160 6.1 Pointeurs intelligents................................. 160 6.2 Comptage de références vs héritage..................... 164 6.3 Faire le bon choix.................................... 165 7. Les structures de données.................................. 166 7.1 Structures unidimensionnelles......................... 166 7.2 Structures multidimensionnelles........................ 169 7.3 Parcourir les structures................................ 170 7.4 Rechercher les performances........................... 170 8. Choisir sa classe String.................................... 171 8.1 Les chaînes C et les langues accentuées.................. 171 8.2 Les normes ISO, Unicode, UCS......................... 172 8.3 Adopter une solution universelle........................ 175 8.4 Construire des tableaux de chaînes...................... 176
6 9. Interactions avec le système d'exploitation................... 178 9.1 Exécuter une commande externe....................... 178 9.2 Les fichiers.......................................... 180 10. La gestion des paramètres................................. 181 10.1 QSettings.......................................... 182 10.2 Une classe propriétaire................................ 184 11. La sérialisation.......................................... 184 11.1 Mécanismes......................................... 185 11.2 Exemples........................................... 187 12. Les fichiers XML......................................... 188 12.1 Écrire dans un fichier XML............................ 189 12.2 Lire un fichier XML.................................. 190 Chapitre 6 QtNetwork 1. Objectifs............................................... 193 2. Intégration et interactions................................. 193 3. Accéder au réseau........................................ 194 3.1 Portée de QtNetwork................................. 194 3.2 Appel bloquant vs non bloquant........................ 195 4. Sockets................................................. 197 4.1 Client TCP......................................... 197 4.1.1 Connexion avec un hôte......................... 198 4.1.2 Envoi d'une requête............................. 199 4.1.3 Lecture d'une réponse............................ 199 4.1.4 Fermeture et nettoyage.......................... 200 4.2 Serveur TCP........................................ 202 4.3 Client UDP......................................... 204 4.3.1 Connexion à un hôte............................ 204 4.3.2 Envoi de données............................... 205 4.3.3 Lecture des données............................. 206
Table des matières 7 4.3.4 Fermeture de la connexion........................ 207 5. Internet................................................ 207 5.1 Résolution DNS..................................... 207 5.1.1 Résoudre un nom de machine..................... 208 5.1.2 Obtenir les enregistrements d'un nom de domaine.... 209 5.2 Échange de fichiers avec FTP........................... 211 5.2.1 Client simple................................... 212 5.2.2 Client évolué................................... 214 5.3 Connexion à un serveur HTTP......................... 216 5.3.1 Création d'une requête........................... 217 5.3.2 Exécution de la requête.......................... 218 5.3.3 Lecture du résultat.............................. 218 5.3.4 Authentification................................ 221 5.4 Le chiffrement avec SSL et TLS......................... 223 6. Les interfaces réseau...................................... 225 Chapitre 7 QtSql 1. Objectifs............................................... 227 2. Intégration et interactions................................. 228 3. Persistance des données................................... 228 3.1 Utilisation d'un serveur de données..................... 228 3.2 Ce que QtSql permet et ne permet pas................... 229 3.3 Le modèle de conception approprié...................... 229 4. Connexion au serveur de données........................... 232 5. Effectuer une requête..................................... 233 5.1 La requête.......................................... 234 5.2 Le résultat.......................................... 235 5.3 Le mode transactionnel............................... 236 5.4 Obtenir les métadonnées.............................. 236 5.5 Rechercher les performances........................... 238
8 5.5.1 Préparation de la requête......................... 240 5.5.2 Exécution de la requête.......................... 241 5.5.3 Stratégie d'instanciation.......................... 242 Chapitre 8 QtGui 1. Objectifs............................................... 243 2. Intégration et interactions................................. 244 3. QGuiApplication et QWindow............................. 244 3.1 QGuiApplication.................................... 244 3.2 QWindow.......................................... 245 4. Rendu 2D.............................................. 246 4.1 Géométrie et positionnement.......................... 247 4.2 Images............................................. 248 4.2.1 QImage....................................... 248 4.2.2 QPixmap...................................... 250 4.3 Dessin 2D.......................................... 251 4.3.1 Dessiner des formes............................. 252 4.3.2 Dessiner du texte............................... 254 5. Rendu 3D.............................................. 255 Chapitre 9 QtWidgets 1. Objectifs............................................... 257 2. Intégration et interactions................................. 258 3. Flux d'application et de GUI............................... 259 4. Modèle objet et modèle-vue................................ 261 4.1 Modèle-vue......................................... 262 4.2 Architecture du code................................. 270
Table des matières 9 5. Créer avec Qt Designer................................... 271 5.1 Organisation du designer.............................. 274 5.2 Mise en page........................................ 275 5.2.1 Ergonomie..................................... 275 5.2.2 Redimensionnement automatique................. 276 5.2.3 Une mise en page plus complexe................... 289 5.2.4 Modèle objet et relations......................... 297 6. Créer «à la main»........................................ 297 7. Modes SDI et MDI....................................... 299 8. Créer un menu.......................................... 304 9. Réagir aux événements.................................... 307 10. Intégrer et afficher les dialogues créés........................ 310 11. Feuilles de style.......................................... 312 12. Gestion des événements................................... 316 13. Ressources.............................................. 320 13.1 Créer un fichier de ressources.......................... 320 13.2 Utiliser une ressource dans le designer................... 321 13.3 Accéder à une ressource depuis le code................... 323 14. Widgets personnalisés.................................... 323 15. Icône de notification (Tray icon)............................ 327 16. Composants graphiques 2D................................ 331 17. Drag and Drop.......................................... 334 17.1 Initialisation des widgets.............................. 335 17.2 Mise en place du drag................................. 336 17.3 Mise en place du drop................................. 338 18. Copier-coller............................................ 339 19. Ouvrir et enregistrer des fichiers............................ 340 20. Généraliser les styles...................................... 342
10 Chapitre 10 QtMultimedia 1. Objectifs............................................... 343 2. Intégration et interactions................................. 344 3. Audio.................................................. 344 3.1 Lister les périphériques................................ 344 3.2 Enregistrer du son.................................... 345 3.3 Lire un fichier....................................... 347 4. Vidéo.................................................. 349 4.1 Enregistrer une vidéo................................. 349 4.2 Lire une vidéo....................................... 350 5. Caméra................................................ 351 5.1 Afficher en direct.................................... 351 5.2 Enregistrer en direct.................................. 352 6. Radio.................................................. 353 6.1 Lire un flux radio.................................... 354 6.2 Enregistrer un flux radio.............................. 356 Chapitre 11 Les modules graphiques et web 1. Objectifs............................................... 357 2. QtSvg.................................................. 357 2.1 Intégration et interactions............................. 357 2.2 Rendu et affichage................................... 358 2.3 Exporter au format SVG.............................. 358 3. QtPrintSupport.......................................... 360 3.1 Intégration et interactions............................. 360 3.2 Choisir l'imprimante................................. 360 3.3 Imprimer un dessin.................................. 361 3.4 Imprimer un widget.................................. 363
Table des matières 11 3.5 Imprimer du texte................................... 363 4. QtWebkitWidgets........................................ 364 4.1 Intégration et interactions............................. 364 4.2 Afficher une page web................................ 364 4.3 Accéder au DOM.................................... 366 4.4 Bases de données HTML 5............................. 369 Chapitre 12 QtTest - qualité du code 1. Objectifs............................................... 371 2. Intégration et interactions................................. 372 3. Scénario de tests......................................... 372 4. Tests unitaires et couverture de code........................ 375 4.1 Les assertions....................................... 376 4.2 Exécution des test................................... 377 4.3 Diversifier les données................................ 379 4.4 Événements GUI..................................... 381 4.5 Tester les performances............................... 383 5. Non-régression.......................................... 384 Chapitre 13 Traduction d une application 1. Objectifs............................................... 385 2. Cycle de traduction...................................... 385 3. Rendre traduisible son application.......................... 387 3.1 Code source......................................... 387 3.2 Vues............................................... 389
12 4. Traduire son application.................................. 390 4.1 Langue et région..................................... 390 4.2 Traduction de l'application............................ 391 4.2.1 Exportation des textes........................... 391 4.2.2 Traduction des textes............................ 391 4.2.3 Compilation des traductions...................... 394 4.3 Intégration des traductions............................ 394 5. Contexte de traduction................................... 396 Chapitre 14 Publication d'une application 1. Objectifs............................................... 397 2. Comprendre les licences................................... 398 3. Les dépendances......................................... 400 4. Créer un installeur universel............................... 401 5. Créer un installeur pour Windows.......................... 402 5.1 Programme compilé avec Microsoft Visual C++.......... 402 5.2 Programme compilé avec mingw........................ 403 6. Créer un installeur pour OS X.............................. 404 6.1 Bundle............................................. 404 6.1.1 Création...................................... 405 6.1.2 Signature...................................... 406 6.2 Fichier DMG........................................ 407 6.3 Paquet d'installation.................................. 409 7. Créer un paquet pour Debian/Ubuntu....................... 409 7.1 Arborescence........................................ 409 7.2 Fichier de contrôle................................... 411 7.3 Création du paquet................................... 412
Table des matières 13 8. Inclure les plugins de Qt.................................. 412 8.1 Windows........................................... 412 8.2 OS X.............................................. 413 8.3 GNU/Linux......................................... 413 9. Tester son application.................................... 414 Chapitre 15 Techniques d'optimisation 1. Objectifs............................................... 415 2. Langages et mode de pensée................................ 416 3. Optimisations........................................... 419 3.1 Le modèle objet...................................... 420 3.2 Le cycle de vie des objets.............................. 422 3.3 Les classes optimisées................................. 425 3.3.1 QByteArray.................................... 425 3.3.2 QStringRef.................................... 427 3.4 Optimiser le processeur............................... 429 4. Lectures complémentaires................................. 431 Index...................................................... 433
Chapitre 5 QtCore et fondations 1. Objectifs QtCore et fondations Dans ce chapitre nous vous présenterons le module principal, le plus important de Qt : le module QtCore. Celui-ci contient un certain nombre de classes indispensables pour la création d'applications comme QString pour les chaînes de caractères, QTimer pour la programmation d'événements, QFile et QDir pour la gestion des fichiers et encore bien d'autres. La présentation de ce module est aussi, et avant toute chose, l'occasion d'introduire les concepts fondamentaux de Qt et la manière dont ce framework facilitera grandement vos travaux de conception et de développement. Parmi ceux-ci nous étudierons particulièrement le modèle objet et la façon d'interagir avec la run-loop en utilisant les signaux et les slots, deux notions propres au framework Qt. 2. Intégration et interactions Le module QtCore est intégré à votre projet grâce à l'ajout du mot clé core dans la déclaration QT de votre fichier.pro. QT += core
108 Remarque Il est pratiquement impossible de s'en passer, sauf si vous faites de la programmation purement C++ sans utiliser aucune des fonctionnalités de Qt. N'importe quel autre module de Qt aura besoin de celui-ci. 3. Découverte de QtCore QtCore est un ensemble d'api qui fournit essentiellement des types de base comme les chaînes de caractères Unicode, les type fichier et répertoire pour l'accès aux disques, des interfaces pour les entrées-sorties et des mécanismes de gestion des événements. Cet ensemble de classes est nommé, dans l'univers Qt, un module. Il contient notamment la classe QObject, la mère des classes contenues dans les autres modules de Qt et de vos futures classes. En outre, la plupart des classes de QtCore sont utilisées par les autres API de Qt. 3.1 Principes de conception Comme nous l'avons évoqué précédemment, la conception de votre application suppose que vous ayez une idée des objets que vous allez créer et de la manière dont ils vont interagir. Dans certains cas, vos objets pourront interagir de manière synchrone et dans d'autres l'interaction sera nécessairement asynchrone, pour être non bloquante. Pour vous aider à simplifier votre conception, nous vous proposons un découpage de vos objets en catégories et le type d'approche que vous devez avoir pour les appels de fonctions sur ces objets. Type d'objet Objet du modèle Helper DAO Factory Contrôleur Widget graphique Type d'appel Synchrone Généralement synchrone Synchrone Synchrone Généralement asynchrone Asynchrone Editions ENI - All rights reserved
QtCore et fondations Chapitre 5 109 Pour vous simplifier la vie, vous ferez hériter tous vos objets directement ou indirectement de la classe QObject. Cela aura l'avantage de vous faire bénéficier de la fonction tr(), membre de la classe QObject et qui vous permettra de traduire facilement vos chaînes de caractères dans différentes langues, ainsi que des mécanismes d'émission et de réception de signaux. Remarque Il vous suffit d'hériter publiquement de QObject pour que les classes enfants bénéficient elles aussi des fonctionnalités de QObject, inutile donc de vous lancer dans un double héritage. Si votre classe parente n'hérite pas de QObject, faites-la hériter de QObject car vous risquez d'être rapidement bloqué. 3.2 La classe QObject Cette classe est au centre de tous les mécanismes complexes de Qt comme l'émission de signaux, la traduction d'interfaces, la hiérarchie d'objets et l'autodestruction des instances, le nommage et les timers. Toutes les classes de Qt en héritent, et toutes vos classes devraient faire de même. Peu importe si elles utilisent les mécanismes cités ci-dessus selon votre idée initiale de la conception de votre application, il est plus que probable que vous en aurez besoin tôt ou tard. Alors autant gagner du temps en faisant hériter vos classes de QObject. 3.2.1 Prototype Voici le prototype classique d'une classe héritant de QObject : class MaClasse : public QObject { Q_OBJECT public : explicit MaClasse(QObject* parent = 0) ; signals : void signalok(void) ;
110 public slots : void onsignalok(void) ; private slots : void onsignalko(void) ; } Votre classe doit donc obligatoirement : hériter publiquement de QObject. utiliser la macro Q_OBJECT avant toute autre déclaration. avoir un ou plusieurs constructeurs possédant au moins un argument QObject* parent initialisé à 0. La macro Q_OBJECT apportera à votre classe les mécanismes de gestion des signaux et des slots. Remarque Notez que toutes les classes qui héritent d'une classe héritant de QObject doivent utiliser la macro Q_OBJECT. Votre classe peut, optionnellement déclarer les sections suivantes : signals : indique que votre classe émettra un ou plusieurs signaux et publie leurs signatures. Un signal peut avoir un ou plusieurs arguments. slots : peut être public, protected ou private. Indique que votre classe peut recevoir des signaux. Les slots peuvent avoir un ou plusieurs arguments. 3.2.2 Copie La classe QObject possède un constructeur de copie et un opérateur d'assignation privés. Elle n'est donc pas copiable. Cela signifie en outre que les classes héritant de QObject ne seront copiables qu'à condition que vous implémentiez vous-même ces fonctions. Vous devez donc ajouter ces deux fonctions à votre classe : MaClasse(const MaClasse& orig) ; MaClasse& operator =(const MaClasse& orig) ; Editions ENI - All rights reserved
QtCore et fondations Chapitre 5 111 Les objets Qt doivent être considérés comme des identités et non des valeurs, à ce propos nous démontrerons qu'il est contre-productif et même risqué de les instancier statiquement. Si un objet héritant de QObject et créé par vous doit être copié, vous devez implémenter les constructeurs par copie et/ou les opérateurs de copie pour procéder vous même à la copie des membres. Ainsi la copie sera un nouvel élément doté de membres dont les emplacements mémoire lui seront propres. Ce sera donc pour vous l'occasion de décider quel type de copie vous ferez de vos objets. Cette notion est d'autant plus importante que de très nombreuses classes de Qt utilisent le lazy-copy et le partage implicite. Les données ne sont copiées que si elles doivent être modifiées, c'est ainsi que Qt tire au maximum profit des qualités de C++ et offre des performances étonnantes. 3.2.3 Internationalisation Aussi connu sous le nom de i18n, ce mécanisme de traduction est accessible grâce à la fonction tr() membre de QObject. Nous aborderons en détail le mécanisme de traduction de votre application dans le chapitre Traduction d une application. 3.3 Métaclasses Qt utilise un système de méta-objets pour faciliter le travail des programmeurs dans la gestion des signaux et l'appel asynchrone des fonctions. Cette métaclasse est directement issue de l'héritage de la classe QObject et de la macro Q_OBJECT. L'utilitaire moc exécuté dans la première partie de la compilation de votre projet générera automatiquement la métaclasse associée à votre classe.
112 La métaclasse sert en quelque sorte d'intermédiaire entre le modèle objet de votre application et celui de Qt, en particulier la run-loop. Contrairement à votre modèle objet les classes du méta-modèle savent comment émettre et recevoir des signaux. La fonction emit() ou l'opérateur emit ainsi que les fonctions déclarées dans les sections signals et slots ne sont jamais appelés directement par vos classes mais redirigés par et vers les méta-objets. Remarque Une métaclasse ajoute des fonctionnalités et des attributs à votre classe et lui permet de s'intégrer parfaitement dans le système de gestion des signaux et slots. Ce mécanisme est totalement transparent pour vous, les classes sont générées automatiquement et leur contenu dépend à la fois du contexte de votre programme et de la manière dont vous faites dépendre vos objets les uns des autres, c'est-à-dire la manière dont vous émettez vos signaux ou faites vos appels asynchrones. En outre, ce mécanisme permet d'effectuer des appels asynchrones sur les fonctions de vos classes grâce à des fonctions comme QMetaObjet::invokeMethod(), ce que C++ ne permet pas naturellement. Editions ENI - All rights reserved