Qt Core

1. Le méta-objet

Comme expliqué dans le chapitre Anatomie d’une application, Qt utilise un système de méta-objets pour faciliter le travail du développeur dans la gestion des signaux et l’appel asynchrone des fonctions.

La méta-classe correspondant au méta-objet est directement issue de l’héritage de la classe QObject et de l’usage de la macro Q_OBJECT.

Lorsque vous utilisez la macro Q_OBJECT, vous ajoutez plusieurs déclarations de fonctions à votre classe. Ces fonctions seront utilisées par Qt pour réaliser les appels de slots et générer les signaux.

Comme vous n’implantez pas vous-même ces fonctions surnuméraires, c’est Qt qui va le faire pendant la phase de construction du programme. L’utilitaire...

1. Paralléliser des tâches

Il faut être très prudent lorsque l’on décide de créer des threads. La plupart du temps, un développeur peu expérimenté créera un ou plusieurs threads pour résoudre un problème de performances ou de blocage de l’interface graphique. C’est une mauvaise interprétation du problème et une solution inadaptée, le blocage de l’interface graphique est révélateur d’un problème conceptuel (voir chapitre Les fondations de Qt).

Avec Qt, il y a très peu besoin de créer des threads, et surtout pas pour résoudre ce genre de problèmes. Les threads doivent être utilisés uniquement pour paralléliser des sous-processus. Par exemple, le parcours d’un arbre avec un algorithme de graphes peut être parallélisé avec un ou plusieurs threads.

S’il s’agit simplement d’un long travail à effectuer, sans parallélisme, il faudra utiliser la run-loop du thread principal et les signaux/slots pour intégrer ce travail de manière fluide dans le flux de l’application.

Il existe plusieurs façons de créer et de gérer des threads : les threads pilotés dont on souhaite connaître l’état et que l’on souhaite pouvoir démarrer et arrêter de manière maîtrisée ainsi que les tâches autonomes que l’on exécute et qui se terminent « dans l’anonymat ».

1. Structures unidimensionnelles

Parmi les structures les plus courantes se trouvent les tableaux. En C, un tableau est déclaré à l’aide des crochets []. L’espace mémoire est alors réservé statiquement à la compilation dans l’espace de données privé du programme.

Le développeur est obligé de définir une dimension pour son tableau dans le code ou lors de son instanciation et ce tableau est alors immuable. Si l’on souhaite l’agrandir, il faut en créer un autre et copier les données de l’un dans l’autre. La recherche est très complexe et les performances faibles.

Qt fournit aux développeurs plusieurs classes qui utilisent le modèle du partage implicite et du copy-on-write (voir chapitre Les fondations de Qt).

Les données ne sont pas stockées directement dans l’objet que vous manipulez mais uniquement le pointeur, les données sont copiées uniquement lorsque c’est nécessaire (en utilisant la fonction takeAt(int i) par exemple, qui renvoie une copie de l’objet situé à l’index i et le supprime de la liste).

Ce qui fait que la taille des données à stocker est celle d’un pointeur et que les performances en écriture sont linéaires...

1. Les chaînes C et les langues accentuées

Une chaîne de caractères en C est un pointeur sur un tableau de char, elle s’écrit char* maChaine et son adresse peut être obtenue en lisant l’adresse du premier caractère : char* laChaine = &maChaine[0]. Elle est délimitée par la valeur 0 située en fin de chaîne. Cette valeur terminale n’appartient pas à la chaîne. Une des principales caractéristiques des chaînes C est donc que les données sont contiguës en mémoire.

Ceci étant dit, le problème du jeu de caractères se pose tout de suite : en Latin1 ou ASCII les caractères sont codés sur un octet, un unsigned char convient donc parfaitement pour coder un caractère ASCII.

Cependant, la table ASCII ne contient pas les caractères des alphabets cyrillique, arabe ou hébreu, pas même le symbole Euro. Il n’est donc pas possible de coder dans le jeu de caractères ASCII le symbole Euro, ni de créer une interface graphique en langue suédoise.

2. Les normes ISO, Unicode, UCS

Pour remédier à ce problème, plusieurs normes ont été créées pour coder tous les caractères qui doivent l’être pour couvrir tous les langages connus. Le standard Unicode contient à ce jour plus de 100 000 caractères, couvre plus de 90 écritures et symboles et est capable de gérer le sens de l’écriture (droite à gauche aussi bien que gauche à droite).

Coder plus de 100 000 caractères dans une table nécessite bien plus qu’un unsigned char qui code au maximum 255 valeurs. Les nouvelles normes utilisent maintenant une taille allant de 1 à 4 octets pour coder un caractère.

Nous n’entrerons...

1. Exécuter une commande externe

Dans de rares cas, il est indispensable d’exécuter une commande externe à l’application, puisée directement dans les exécutables du système d’exploitation.

Par exemple, si l’utilisateur souhaite « pinger » une machine du réseau, il ne peut pas le faire simplement avec les API de Qt, et en tout état de cause une telle requête réseau nécessite les droits d’administrateur pour être exécutée.

L’exécution d’un processus externe est très simple avec la classe QProcess. Comme l’exécution d’une commande externe est par nature aléatoire, Qt rend cette exécution asynchrone par défaut.

L’exécution d’une commande externe s’effectue comme ceci :...

1. QSettings

Qt offre un moyen très simple de gérer les réglages d’une application : la classe QSettings. Celle-ci fonctionne sur tous les systèmes d’exploitation mais n’offre pas de moyen de transférer les paramètres d’un système à un autre.

Sous Windows, c’est la base de registres qui sera utilisée par défaut. Sous OS X c’est un fichier XML stocké dans la sandbox et sous Unix c’est un fichier .ini.

Ces formats de stockage par défaut peuvent être outrepassés par le développeur pour enregistrer les réglages dans un fichier XML stocké à un emplacement qu’il aura lui-même défini.

Avant de pouvoir utiliser correctement la classe QSettings, le développeur devra prendre soin de « paramétrer » son application. Trois paramètres sont importants :

QCoreApplication::setOrganisationName("MonEntreprise") ; ...

1. Mécanismes

Pour sérialiser un objet avec Qt, il suffit d’utiliser la classe QTextStream si l’on souhaite l’enregistrer sous forme de texte, ou la classe QDataStream si l’on souhaite enregistrer des données binaires. Le second est plus...

1. Écrire dans un fichier XML

La classe QXmlStreamWriter fonctionne de manière événementielle, en parcourant le flux de données (le fichier XML) du début à la fin de façon séquentielle. Ainsi, les balises sont lues dans l’ordre dans lequel elles figurent dans le fichier, ce qui implique qu’elles soient aussi écrites dans l’ordre dans lequel vous les fournissez à la classe.

La création d’un document commencera toujours par l’appel à la fonction writeStartDocument() et se terminera par un l’appel à la fonction writeEndDocument(). Qt se chargera alors d’écrire les balises déclaratives adéquates.

Ensuite tous les éléments sont ajoutés grâce à la fonction writeStartElement(QString name) qui prend en paramètre le nom de l’élément à ajouter.

Pour ajouter des attributs à l’élément courant (celui qui est actuellement ouvert), nous utiliserons la fonction writeAttribute(QString name, QString...

1. Lire un fichier JSON

L’interface entre un fichier et une structure de données JSON est la classe QJsonDocument. 

Pour ouvrir le fichier stocké sur le disque dur :

QFile fichier(":/fichier.json"); 
 
//Ouverture du fichier en lecture uniquement 
if(fichier.open(QFile::ReadOnly)) { 
   //Récupération du contenu du fichier 
   donnees = fichier.readAll(); 
 
   //Interprétation du fichier JSON 
   QJsonDocument doc = QJsonDocument::fromJson(donnees, &error); 
   if(error.error != QJsonParseError::NoError) { 
       qCritical() << "Impossible d'interpréter le fichier : 
" << error.errorString(); 
   } else { 
       qDebug() << "Fichier interprété"; 
   } 
}...

1. Automate simple

Supposons un feu tricolore. Celui-ci a trois états possibles :

Les transitions entre ces trois états sont réalisées après un décompte de deux secondes à chaque fois.

L’implémentation de cet automate en Qt s’effectuera ainsi :

//Instanciation d'un automate et des états 
QStateMachine automateFeux; 
QState etatFeuVert; 
QState etatFeuOrange; 
QState etatFeuRouge; 
 
//L'événement déclencheur des transitions 
QTimer timer; 
 
//Ajout des états à l'automate 
automateFeux.addState(&etatFeuVert); 
automateFeux.addState(&etatFeuOrange); 
automateFeux.addState(&etatFeuRouge); 
 
//Définition de l'état initial de l'automate 
automateFeux.setInitialState(&etatFeuRouge); 
 
//Définition des transitions 
etatFeuRouge.addTransition(&timer, SIGNAL(timeout()), &etatFeuVert); 
etatFeuVert.addTransition(&timer, SIGNAL(timeout()), &etatFeuOrange); 
etatFeuOrange.addTransition(&timer, SIGNAL(timeout()), &etatFeuRouge); 

Nous disposons à présent d’un automate à trois états. Un unique timer déclenche les transitions entre états. C’est le signal timeout() du timer qui déclenche la transition.

Une transition est définie comme ceci :

etatSource.addTransition(objetDéclencheur, signalDéclencheur, 
etatDestination); 

Pour démarrer au automate, il suffit d’appeler la fonction start().

automateFeux.start(); 

Un automate possède sa propre event-loop. Si la fonction start() n’est pas appelée, il ne pourra recevoir de signaux ni effectuer les transitions.

Après avoir démarré l’automate, nous devons...

1. Conversion d’endianisme

Il est parfois nécessaire de changer l’endianisme de données en provenance d’une autre architecture, notamment si vous échangez des données brutes sur un réseau.

Pour pouvoir utiliser les fonctions de conversion, vous devez inclure le fichier QtEndian :

#include <QtEndian> 

La conversion d’un entier vers gros-boutiste se fait ainsi :

quint32 a = 0x00112233; 
quint32 a2 = qToBigEndian(a); 
quint16 b = 0x00FF; 
quint16 b2 = qToBigEndian(b); 
 
qDebug() << "int32 little endian (x86) = " << QString::number(a, 16); 
qDebug() << "int32 big endian (x86) = " << QString::number(a2, 16); 
 
qDebug() << "int16 little endian (x86) = " << QString::number(b, 16); 
qDebug() << "int16 big endian (x86) = " << QString::number(b2, 16); 

Cela produit le résultat suivant :

quint32 little endian (x86) = "112233" 
quint32 big endian (x86) = "33221100" 
quint16 little endian (x86) = "ff" 
quint16 big endian (x86) = "ff00" 

Bien entendu, ce résultat ne vaut que si le code est exécuté sur une architecture petit-boutiste. Dans le cas contraire, la fonction qToBigEndian() renverra la valeur d’entrée.

La conversion d’un entier depuis gros-boutiste se fait ainsi :

quint32 a = 0x33221100; 
quint32 a2 = qFromBigEndian(a); 
quint16 b = 0xff00; 
quint16 b2 = qFromBigEndian(b); 
 
qDebug() << "quint32 big endian (x86) = " << QString::number(a, 16); 
qDebug() << "quint32 little endian (x86) = " << QString::number(a2, 16); 
 
qDebug() << "quint16 big endian (x86) = " << QString::number(b, 16); 
qDebug() << "quint16 little endian (x86) = " << QString::number(b2, 16); 

Cela produira le résultat suivant :...