Les fondations de Qt

Les Types Qt

La notion de Type est elle aussi assez spécifique à Qt. Elle traverse tout le framework pour servir, notamment, à la construction d’interfaces graphiques Qt Quick. Les objets déclarés dans une scène Qt Quick sont des Types QML. Chaque Type QML s’appuyant indirectement sur une classe C++, les caractéristiques d’un Type Qt sont logiquement à rechercher dans les classes C++.

La définition d’un Type Qt répond aux exigences imposées par la classe QMetaType suivantes :

L’exemple ci-dessous répond à ces exigences et peut être considéré comme un Type Qt :

class MonType { 
public : 
  MonType() = default; 
  virtual ~MonType() = default; 
  MonType(const MonType&) = default; 
  MonType& operator=(const MonType&) = default; 
}; 

Cette déclaration n’est que le minimum exigé pour que la classe soit considérée comme un Type Qt. Vous...

La classe QObject

La classe QObject est au centre de toutes les API de Qt. Elle est la mère de pratiquement toutes les classes, hormis les conteneurs de données et certaines classes aux propriétés spécifiques.

Elle possède des caractéristiques particulières qui en font une classe incontournable quand on souhaite bénéficier des possibilités offertes par Qt, mais elle impose aussi certaines contraintes, faisant ainsi de Qt un framework.

class MaClasse : public QObject { 
... 
} 
 
int main(int argc, char** argv) { 
    MaClasse a ; 
    MaClasse b(&a) ; //Cette ligne ne compile pas 
    MaClasse c = a ; //Celle-ci non plus 
} 

Héritage

Qt s’appuie totalement sur C++, à ce titre toutes les règles d’héritage de C++ s’appliquent.

Comme nous l’avons vu ci-dessus, la spécialisation de la classe QObject impose un certain nombre de contraintes, en particulier la prise en charge de la copie des données et la gestion de l’affinité de thread.

Optimisation des conteneurs

Au sein de Qt, tous les conteneurs de données ainsi que de très nombreuses classes qui encapsulent un tant soit peu de données, sont conçus sur le modèle de la copie à l’écriture.

La copie à l’écriture est une technique couramment utilisée en conception objet, car elle permet d’optimiser à la fois la consommation de mémoire et l’utilisation du processeur.

Cette technique repose sur deux principes : le comptage de références et la séparation entre les données d’une classe et son interface (patron de conception Proxy). Le premier permet de gérer automatiquement le cycle de vie de l’instance créée et de passer les objets par valeur, et le second permet de ne copier les données que lorsque c’est nécessaire.

Nous verrons, dans les chapitres suivants, ces techniques fondamentales sur lesquelles sont fondées la plupart des structures de données de Qt.

Le patron de conception principal sur lequel est fondé ce mécanisme est le Proxy.

Outre le fait que tous les conteneurs de données de Qt sont optimisés, cette technique offre des gains de performance extraordinaires. En effet, elle permet de passer des arguments de fonctions par valeur, sans jamais copier les données. 

Observons l’exemple suivant :

1  void fonction(QString str) { 
2    QString str2 = str; 
3 
4    if(<condition>) { 
5      return str2; 
6    } 
7 
8    ...   
9  } 
10 
11 void main() { 
12   QString str("Ceci est une chaine de caractères"); 
13 
14   fonction(str); 
15 } 

En principe, avec un autre framework C++, la chaine de caractères créée à la ligne 13 est copiée 3 fois : aux lignes 1, 2 et 5. Le constructeur par défaut d’une classe effectue une copie profonde de ses membres.

Avec Qt, même si l’objet créé en ligne 13 est bien copié 3 fois, la chaîne de caractère contenue dans l’instance de QString, elle n’est jamais copiée....

La classe QVariant

La classe QVariant est une classe très utilisée dans certains modules de Qt, notamment ceux qui servent à faire des échanges de données entre applications comme Qt Sql ou l’ancien module Qt Xml dont les mécanismes sont à présent implantés dans Qt Core (voir la section Les fichiers XML dans le chapitre Qt Core).

La classe QVariant est utilisée pour le transtypage. QVariant n’est pas un type, C++ ne fournit pas de type variant. Cela n’est pas non plus équivalent au type auto de C++-11.

Dans le cas où vous lisez un fichier XML ou que vous parcourez les enregistrements résultant d’une requête SQL, vous ne traitez que des instances de la classe QVariant. Vous devez ensuite convertir ces variants en un type exploitable par votre application.

L’intérêt majeur de la classe QVariant est de permettre de manipuler des types différents, de les convertir sans erreur ni exception, et de n’avoir qu’un type à manipuler dans une API.

Par exemple, la conversion d’un booléen en chaîne de caractères et inversement sera faite ainsi :

QVariant var(false) ; 
 
bool b = var.toBool() ; 
qDebug() << "booléen : " << b ; 
 
QString s = var.toString() ; 
qDebug() << "chaine :...

Gestion des erreurs

Qt n’émet jamais d’exception, car il serait absurde de déclencher une exception durant un traitement asynchrone, nous n’aurions pas la possibilité d’attraper (catch) l’exception.

En revanche, dans les API de Qt vous trouverez principalement deux manières de gérer les erreurs : bool* ok = 0 et error().

QString val = "1a" ;  
bool ok(true);  
 
QVariant var(val) ;  
int i = var.toInt(&ok) ;  
if(!ok)  
   qDebug() << "Erreur de conversion" ; 

Le modèle event-driven

Parmi les notions que nous avons introduites précédemment pour décrire les paradigmes sur lesquels repose Qt en tant que framework, figurait le modèle event-driven.

Nous revenons sur cette notion dans ce chapitre afin de comprendre pourquoi elle est si importante et à quel point elle se situe au cœur de la conception de Qt, et donc de vos futures applications.

L’assimilation de ces notions est cruciale pour réaliser des applications performantes, qui consomment peu de ressources et dont le fonctionnement est fluide en toutes circonstances.

1  void b() {  
2     std::cout << "Ligne affichée en deuxième" << std::endl ; ...

Les ressources

Les applications modernes contiennent parfois du son et des polices de caractères spécifiques, mais surtout beaucoup d’images et d’icônes. Tous ces objets sont stockés dans des fichiers externes à l’application lorsque vous la développez.

Si vous conservez ces fichiers hors de votre application, il vous faudra les fournir en même temps que l’exécutable de votre programme si vous le diffusez. Cela peut rapidement rendre complexe la diffusion de vos logiciels ainsi que leur maintenance.

Pour éviter ces problèmes, Qt propose un système de ressources. Une ressource est un fichier source qui est compilé et lié dans l’exécutable de votre logiciel durant la phase de compilation.

Le fonctionnement est très simple :

Ainsi, votre exécutable sera plus gros, car il contiendra, en plus de votre code source, celui...

Les propriétés

L’intégration de C++ avec Quick, et en particulier le langage QML implique certaines contraintes dans le code des classes C++. Comme nous l’avons vu dans la section Les Types Qt, une classe est considérée comme un type Qt lorsqu’elle possède certaines caractéristiques, en particulier un constructeur par défaut.

QML est un langage déclaratif, il n’existe pas d’opération d’instanciation, ni de destruction. Pour créer un objet il suffit de déclarer le Type Qt et d’utiliser des accolades :

main.qml 
 
UnType {} 

Cette déclaration suffit à provoquer la création d’une instance de UnType, ce Type étant codé dans une classe C++.

Vous remarquerez également qu’il n’y a pas d’argument à une déclaration, comme on peut le voir avec un constructeur C++ qui permette de définir des variables membres en même temps que l’instanciation de la classe.

En QML, pour modifier des membres de la classe on utilise le plus souvent des propriétés :

main.qml 
 
UnType { 
 id: letype 
 val: 1552 
} 

La déclaration ci-dessus est équivalente au code C++ suivant :

UnType* letype = new UnType(this); 
letype->val = 1552; 

Ceci suppose que le membre val soit public...