[Plan du site] Vous êtes ici --- > Le Site du Zéro > Les tutoriels > Officiels > Programmation > Apprenez à programmer en C++ ! > Annexes > Ce que vous pouvez encore apprendre > Lecture du tutoriel

Ce que vous pouvez encore apprendre

Qu'on se le dise : bien que le tutoriel C++ s'arrête là, vous ne savez pas tout sur tout. D'ailleurs, personne ne peut vraiment prétendre tout savoir sur le C++ et toutes ses bibliothèques.

L'objectif n'est pas de tout savoir, mais d'être capable d'apprendre ce dont vous avez besoin lorsque c'est nécessaire.

Si je devais moi-même vous apprendre tout sur le C++, j'y passerais toute une vie (et encore, ça serait toujours incomplet). J'ai autre chose à faire, et j'en serais de toute façon incapable.
Du coup, plutôt que de tout vous apprendre, j'ai choisi de vous enseigner de bonnes bases tout au long du cours. Cette annexe a pour but, maintenant que le cours est fini, de vous donner un certain nombre de pistes pour continuer votre apprentissage.

J'ai découpé ce chapitre en 3 parties :

Ce que vous pouvez encore apprendre sur le langage C++ lui-même.
Ce que vous pouvez encore apprendre sur la bibliothèque standard du C++, que nous avons seulement effleuré ici.
Ce que vous pouvez encore apprendre sur la bibliothèque Qt.

Cette annexe est seulement là pour vous présenter de nouvelles notions, pas pour vous les expliquer. Ne soyez donc pas surpris si je suis beaucoup plus succint que d'habitude. Imaginez cette annexe comme un sommaire de ce qu'il vous reste à apprendre.

Sommaire du chapitre :

... sur le langage C++
... sur la bibliothèque standard
... sur la bibliothèque Qt

... sur le langage C++

Le langage C++ est suffisamment riche pour qu'il vous reste encore de nombreuses notions à découvrir. Certaines d'entre elles sont particulièrement complexes, je ne vous le cache pas, et vous n'en aurez pas besoin tout le temps.

Toutefois, au cas où vous en ayez besoin un jour, je vais vous présenter rapidement ces notions. A vous ensuite d'approfondir vos connaissances, par exemple en lisant des tutoriels écrits par d'autres Zéros sur le C++, en lisant des livres dédiés au C++, ou tout simplement en faisant une recherche Google.

Voici les notions que je vais vous présenter ici :

L'héritage multiple
Le masquage de méthodes
Les exceptions
Les templates
Les namespaces
Les classes et fonctions amies
Les méthodes virtuelles pures et les classes abstraites

L'héritage multiple

L'héritage multiple consiste à hériter de plusieurs classes à la fois. Nous avons déjà fait cela dans la partie sur Qt, pour pouvoir utiliser une interface dessinée dans Qt Designer :

Pour hériter de plusieurs classes, il suffit de mettre une virgule entre les noms de classe, comme on l'avait fait :

Code : C++

class FenCalculatrice : public QWidget, private Ui::FenCalculatrice
{

};

C'est une notion qui paraît simple mais qui, en réalité, est très complexe.

En fait, la plupart des langages de programmation plus récents, comme Java et Ruby, ont carrément décidé de ne pas gérer l'héritage multiple. Pourquoi ? Parce que ça peut être utile dans certaines conditions assez rares, mais si on l'utilise mal (quand on débute) ça peut devenir un cauchemar à gérer.

Bref, jetez un coup d'oeil à cette notion, mais juste un coup d'oeil de préférence, car vous ne devriez pas y avoir recours souvent.

Le masquage de méthodes

Lorsqu'une classe hérite d'une autre classe, il est possible d'avoir 2 méthodes du même nom (et du même prototype).

Prenons un exemple :

Ici, la classe Guerrier qui hérite de Personnage possède une méthode qui s'appelle elle aussi coupDePoing. Si notre guerrier fait un coupDePoing, c'est la méthode définie dans Guerrier qui sera utilisée, celle de Personnage sera ignorée (masquée).

Nanoc en parle plus en détail dans son tutoriel sur l'héritage. N'hésitez pas à aller y jeter un oeil.

Les exceptions

Les exceptions sont un mécanisme du C++ qui permet de gérer les erreurs.

En temps normal, pour vérifier qu'une fonction n'a pas eu d'erreur, celle-ci renvoie un booléen. Il nous suffit alors de tester la valeur de retour comme ceci :

Code : C++

if (maFonction())
{
    cout << "Ca a marché !";
}
else
{
    cout << "Erreur lors de l'appel de maFonction()";
}

Ca marche, mais ce n'est pas très pratique dans un gros programme. En effet, parfois on a besoin de faire "remonter" l'erreur à la fonction appelante, parce qu'on ne peut pas traiter l'erreur de suite. Ici, on mélange le code "utile" du programme avec la gestion des erreurs.

Un des gros intérêt des exceptions, c'est qu'elles vous permettent de regrouper vos erreurs. Cela fonctionne en 2 temps :

On essaie (try) d'exécuter certaines fonctions.
Si une de ces fonctions a généré une erreur, on la récupère (catch) et on gère l'erreur dans un endroit bien défini du code.

Exemple :

Code : C++

try // On essaie d'exécuter les lignes de codes qui suivent
{
    maFonction();
    autreFonction();
    encoreUneAutreFonction();
}
catch (const string& erreur) // Si une erreur est survenue dans les lignes précédentes, on exécute ces lignes
{
    cout << "Erreur ! Raison : " << erreur;
}

Il faut que les fonctions maFonction(), autreFonction() et encoreUneAutreFonction() envoient un message d'erreur à l'aide du mot-clé throw si jamais elles rencontrent une erreur. Dans ce cas, si une erreur est détectée, les instructions situées dans le bloc catch seront exécutées.

Pour plus d'informations sur les exceptions, je vous recommande la lecture du tutoriel de Nanoc.

Pour information, les exceptions ne sont pas bien utilisables avec la bibliothèque Qt, qui ne les prend pas correctement en charge. Vous ne pouvez donc pas vraiment utiliser d'exceptions dans un programme Qt.

Les templates

Les templates sont une notion pratique et puissante du C++ que nous avons déjà rencontrée, sans vraiment expliquer le fonctionnement derrière.

Imaginez que vous ayez besoin d'écrire une fonction (ou une classe) qui doit pouvoir accepter n'importe quel type de paramètre, et qui doit pouvoir retourner n'importe quel type. En fait, vous avez besoin d'écrire une fonction évolutive qui s'adapte à tous les types de données.

Voici par exemple une fonction d'addition qui utilise le principe des templates :

Code : C++

template<class T> T addition(T element1, T element2)
{
    T somme = element1 + element2;
    return somme;
}

La fonction annonce dès le début qu'elle utilise le principe des templates. Le <class T> indique que le symbole T représente n'importe quel type de variable.

Dans la fonction ensuite, on voit que celle-ci retourne un élément de type T et qu'elle en reçoit 2 de type T eux aussi. En fait, à la compilation, le "T" sera remplacé par le type nécessaire. Par exemple, T sera remplacé par int si vous appelez la fonction comme ceci :

Code : C++

1 2	int a = 10, b = 15, c = 0; c = addition(a, b); // T sera remplacé par int car a, b et c sont des int

Les templates peuvent aussi être utilisés par des classes. Cela permet à la bibliothèque standard du C++ (et à Qt aussi d'ailleurs) de créer des classes qui gèrent des tableaux d'objets à taille variable.

Dans le chapitre sur le réseau, nous avions par exemple utilisé un tableau QList qui utilisait le principe des templates :

Code : C++

1	QList<QTcpSocket *> clients;

Les QList sont des tableaux qui acceptent n'importe quel type de données et dont la taille peut varier. Entre les chevrons < et >, on indique à la classe ce qu'on va stocker à l'intérieur (ici des pointeurs sur QTcpSocket). Grâce aux templates, les QList peuvent donc stocker n'importe quel type de données !

Vous pouvez retrouver une explication plus détaillée des templates par foester dans son tutoriel.

Les namespaces

Souvenez-vous. Dès le début du tutoriel C++, je vous ai fait utiliser les objets cout et cin qui permettent d'afficher un message dans la console et de récupérer le texte saisi au clavier.

Voici le tout premier code source C++ que vous aviez découvert :

Code : C++

#include <iostream>

int main()
{
        std::cout << "Hello world!" << std::endl;
        return 0;
}

Le préfixe "std::" correspond à ce qu'on appelle un namespace, c'est-à-dire espace de nom en français. Les namespaces sont utiles dans de très gros programmes où il y a beaucoup de noms de classes et de variables différents.

Quand vous avez beaucoup de noms différents dans un programme, il y a un risque que 2 classes aient le même nom. Par exemple, vous pourriez utiliser 2 classes Couleur dans votre programme : une dans votre bibliothèque "Jeu3D" et une autre dans votre bibliothèque "Fenetre".
Normalement, avoir 2 classes du même nom est interdit... sauf si ces classes sont chacune dans un namespace différent ! Imaginez que les namespaces sont comme des "boîtes" qui évitent de mélanger les noms de classes et de variables.

Si la classe est dans un namespace, on doit placer le nom du namespace en préfixe devant :

Code : C++

1
2

Jeu3D::Couleur rouge; // Utilisation de la classe Couleur située dans le namespace Jeu3D
Fenetre::Couleur vert; // Utilisation d'une AUTRE classe appelée elle aussi Couleur, dans le namespace Fenetre

Le namespace "std" est utilisé par toute la bibliothèque standard du C++. Il faut donc mettre ce préfixe devant chaque nom issu de la bibliothèque standard (cout, cin, endl, string...).
Il est aussi possible, comme je vous l'avais dit, d'utiliser la directive "using namespace" au début du fichier :

Code : C++

1	using namespace std;

Grâce à ça, dans tout le fichier le compilateur saura que vous faites références à des noms définis dans le namespace std. Cela vous évite d'avoir à répéter "std::" partout.

Certains programmeurs préfèrent éviter d'utiliser "using namespace" car, en lisant le code ensuite, on ne sait plus vraiment à quel namespace le nom se rapporte.

Pour plus d'informations, lisez le tutoriel sur les namespaces de Vanger.

Les classes et fonctions amies

Vous vous souvenez de la notion de portée ? Je l'espère en tout cas !
Non ? Si je vous dis "public", "private", "protected", ça vous revient ?

Ah, j'aime mieux ça.

Ces mots-clés servent à définir la portée d'un attribut ou d'une méthode dans une classe :

Une méthode "public" pourra être appelée depuis n'importe quelle fonction de votre code.
Une méthode "private" ne pourra être appelée que par une autre méthode de votre classe..
Une méthode "protected" est identique à private, à la différence près que les classes filles y auront quand même accès elles aussi.

A cette liste, il faudrait rajouter la portée "friend". Je n'en ai pas parlé dans le cours car c'est une notion à double tranchant : elle peut être très pratique dans certains cas, mais si vous l'utilisez mal vous risquez de ne plus respecter le principe d'encapsulation (et donc coder comme des malpropres >_<

).

Pour ceux qui veulent en savoir plus et qui me promettent de ne pas utiliser abusivement friend, je les autorise à lire le tutoriel sur l'amitié de Nanoc (friend = ami au cas où vous n'auriez pas percuté :-°

Les méthodes virtuelles (pures) et les classes abstraites

Il y aurait beaucoup à dire sur les notions de méthodes virtuelles pures, méthodes virtuelles, classes virtuelles et classes abstraites. La pire erreur serait de mettre tout dans le même paquet. Ces notions sont chacune très différentes les unes des autres et ne signifient pas du tout la même chose à chaque fois (quel intérêt d'avoir mis des noms similaires ? Bah juste pour vous embrouiller :-°

).

Ce que vous devez retenir c'est que ce sont des notions avancées de C++ dont on n'a besoin que dans des cas très précis, donc rares.

Je vous conseille de vous attarder en premier sur la notion de méthodes virtuelles pures : ce sont des méthodes que l'on définit sans implémenter. Dans ce cas, la classe est dite "abstraite" et on ne peut pas l'instancier (on ne peut pas créer d'objets avec). L'implémentation de la méthode virtuelle pure doit alors être faite dans une classe fille.

Cette notion est expliquée par cysboy dans son tutoriel Java. Oui c'est pour du Java je sais, mais le principe est le même et son tutoriel a l'avantage de montrer le principe à l'aide de nombreux schémas.
Pour des explications spécifiques au C++, jetez un oeil au cours de Christian Casteyde ou à la FAQ C++ de Developpez.com.

Je vous laisse faire des recherches supplémentaires à ce sujet si le coeur vous en dit, mais ne commencez pas par apprendre ça car ce sont des notions tout de même assez délicates.

... sur la bibliothèque standard

Comme le C, le C++ propose une bibliothèque standard. L'avantage par rapport à une bibliothèque externe comme Qt, c'est justement que cette bibliothèque est installée par défaut sur tous les ordinateurs. Pas besoin de livrer des DLL supplémentaires.

La bibliothèque standard du C++ est très riche (et parfois complexe). Je vous ai présenté quelques notions de base à ce sujet dans mon cours :

Les entrées / sorties avec cin et cout.
Les chaînes de caractères à taille variable, avec la classe string.

Ca, c'est vraiment un tout petit bout de la bibliothèque standard C++ qui propose en fait de nombreux autres outils. Comme pour la classe string, ces outils sont plutôt faciles à utiliser et très pratiques, mais ils font appels à des mécanismes complexes en interne.

Les différentes parties de la bibliothèque standard du C++

La bibliothèque standard du C++ peut être découpée comme ceci :

La bibliothèque de flux : c'est elle qui gère les flux d'entrée / sortie cin et cout, en utilisant en particulier les opérateurs << et >>.
La gestion des chaînes de caractères : avec la classe string.
La bibliothèque standard du C : elle est aussi utilisable en C++. En effet, certaines fonctions basiques (comme les fonctions mathématiques) n'ont pas été réécrites en C++ car cela n'aurait eu aucun intérêt. Par conséquent, on utilise toujours les fonctions du C.
La bibliothèque standard de templates, aussi appelée STL (Standard Template Library) : c'est une grosse grosse partie de la bibliothèque standard du C++ qui utilise massivement le principe des templates que je vous ai présenté un peu plus haut.

La STL

C'est clairement le plus gros morceau de la bibliothèque standard du C++. Il s'agit d'un ensemble de classes et d'algorithmes qui utilisent les templates pour créer des conteneurs capables de stocker n'importe quel type de données.

Présentation de la STL

Quand on veut stocker plusieurs objets du même type en temps normal, on utilise généralement un tableau :

Code : C++

1 2	int tableauEntiers[10]; string tableauChaines[5];

Le problème, c'est que ce genre de tableau a une taille fixe. Le premier ne peut stocker que 10 entiers, et le second que 5 chaînes (string) maximum.

Parfois, on ne sait pas combien de données différentes notre tableau va contenir. Ca peut très bien être 3 comme 300... Imaginez par exemple un jeu en ligne : on ne sait pas combien de joueurs vont participer à l'avance quand on écrit le code. Rappelez-vous de notre programme de Chat : on ne sait pas combien de gens vont chatter.

Je sais ! On n'a qu'à créer un très grand tableau pour être sûr de pouvoir tout stocker !
int tableauEntiers[999999]; et hop là ! Le problème est réglé !

Ca va pas la tête ? o_O

En faisant ça, vous consommez beaucoup trop de mémoire inutilement. Ce n'est pas du tout efficace.

En fait, le top serait d'avoir un tableau dont la taille change en fonction des besoins. Il fait 3 cases s'il y a 3 éléments, il s'agrandit automatiquement à 4 cases si on ajoute un élément, se réduit à 2 cases si on en enlève un.

Figurez-vous que c'est tout le principe de la STL. Elle propose des classes "conteneur" qui se comportent comme des tableaux dynamiques (= à taille variable). Le truc, c'est que la STL propose de très nombreuses classes conteneur. On aurait pu se dire qu'une aurait suffit, mais en fait non.

Tout dépend de vos besoins. La FAQ STL de Developpez.com propose un schéma qui fait un peu peur au début mais qui résume en fait très bien la situation.
Tout dépend comme vous le voyez si vous avez besoin de créer un tableau ordonné ou si au contraire l'ordre n'a pas d'importance. Tout dépend aussi de la fréquence à laquelle vous allez insérer des éléments dans les conteneurs, de la façon dont vous voulez les lire, etc.

Dans tous les cas, les conteneurs sont capables de stocker n'importe quel type de données grâce aux templates.

Liste des classes de la STL

Voici une liste des différents conteneurs proposés par la STL :

stack
queue
priority_queue
list
vector
dequeue
map
set
multi_map
multi_set

Chacun d'entre eux a ses spécificités. Le schéma dont je vous ai parlé vous permet de faire votre choix parmi la jungle des conteneurs disponibles.

Un exemple simple : la classe vector

Commencez par exemple par la classe vector, c'est un bon début pour découvrir la STL.

On peut se servir de vector comme d'un tableau à taille dynamique. Voici un exemple d'utilisation, pour un vector qui va stocker des int :

Code : C++

vector<int> tableauEntiers; // Création d'un tableau d'entiers à taille variable

tableauEntiers.push_back(14); // Insère 14
tableauEntiers.push_back(27); // Insère 27
tableauEntiers.push_back(83); // Insère 83

cout << tableauEntiers[1]; // Affiche 27

Le vector ne nécessite donc pas que l'on définisse une taille lors de sa création. On ajoute des éléments à la fin du tableau avec la méthode push_back(). On peut ensuite accéder à n'importe quel élément du vector comme si c'était un tableau (merci la surcharge de l'opérateur [] ! ).

Pour connaître la taille actuelle du tableau, appelez la méthode size(). Dans notre exemple précédent, cette méthode aurait renvoyé 3.

Il y aurait beaucoup à dire encore sur les vector. Nanoc leur a justement dédié un tutoriel que je vous invite à lire.

Les algorithmes

La STL propose de nombreuses fonctions capables d'effectuer des opérations sur ces conteneurs :

Copier le tableau
Trier les éléments dans le tableau
Trouver l'élément le plus petit ou le plus grand
Scinder ou fusionner un tableau
Rechercher dans un tableau
Supprimer les doublons

Bref, toutes les opérations de base sont déjà codées pour vous ! Il n'y a plus qu'à les utiliser.

Où trouver de la documentation ?

Comme je ne peux pas vous expliquer tout ça à moins d'y passer un temps fou, il faudra lire la documentation ou rechercher d'autres tutoriels.

Personnellement, bien qu'il n'y ait pas de "site officiel" comme pour Qt, j'ai tendance à utiliser ce site comme documentation de référence pour la bibliothèque standard du C++ :

www.cppreference.com

Vous y retrouverez en particulier la liste des classes de la STL et des algorithmes qui y sont proposés.

Bonne lecture

... sur la bibliothèque Qt

Dans le cours, nous avons eu largement le temps d'étudier la bibliothèque Qt et de découvrir à quel point il était simple de créer des GUI (fenêtres).

Nous avons aussi découvert que cette bibliothèque était énorme, et qu'on devait plutôt parler de framework (ensemble de bibliothèques).
Je vous rappelle que Qt est constitué de plusieurs modules :

GUI
OpenGL
Dessin
Réseau
SVG
Scripts
XML
SQL
Core

En ce qui nous concerne, nous avons eu l'occasion de bien faire le tour du module GUI (c'était le but !) et nous nous sommes initiés aussi un peu au réseau.

Malgré cela, nous n'avons pas tout tout vu sur le module GUI. D'autre part, nous avons seulement effleuré le module réseau, et nous n'avons pas du tout parlé des autres modules.
Je vais, dans cette annexe, vous présenter brièvement quelques-uns de ces modules. Je ne vais pas vous les expliquer (ce serait beaucoup trop long !), juste vous en parler pour vous donner quelques pistes.

Surtout, pensez à vous rendre sur la doc pour en savoir plus !

Module GUI : des petites fonctionnalités cachées

Il y a quelques widgets et fonctionnalités plus rares dont je n'ai pas eu l'occasion de parler. Je vais vous en présenter quelques-uns rapidement ici. Ils ne sont pas toujours utiles mais ça peut être bien de savoir qu'ils existent.

Cette liste des autres fonctionnalités à découvrir n'est pas complète, loin de là. Je ne connais pas tout. Je vous donne juste une idée des "petites choses" que vous pouvez découvrir si vous passez un peu de temps dans la doc.

QCalendarWidget : un calendrier tout prêt

Le widget QCalendarWidget permet d'afficher un calendrier :

Si vous devez réaliser un agenda ou si l'utilisateur doit sélectionner une date, nul doute que ce widget vous fera gagner un temps fou !

QSplashScreen : pour faire patienter au démarrage

Parfois, certains programmes sont un peu longs à charger. Pour faire patienter l'utilisateur, on affiche un "splash screen", c'est-à-dire une petite image au centre de l'écran. C'est ce que fait Code::Blocks au démarrage par exemple.

Qt permet de créer un "splash screen" avec la classe QSplashScreen. On l'utilise en général dans le main, juste avant d'ouvrir la fenêtre principale :

Code : C++

#include <QApplication>
#include <QTranslator>
#include <QLocale>
#include <QLibraryInfo>
#include <QSplashScreen>
#include <QPixmap>
#include "FenPrincipale.h"

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);

    QSplashScreen splash(QPixmap("znavigo.png"), Qt::WindowStaysOnTopHint);
    splash.show();

    // Traduction des chaînes prédéfinies par Qt dans notre langue
    QString locale = QLocale::system().name();
    QTranslator translator;
    translator.load(QString("qt_") + locale, QLibraryInfo::location(QLibraryInfo::TranslationsPath));
    app.installTranslator(&translator);

    // Ouverture de la fenêtre principale du navigateur
    FenPrincipale principale;
    principale.show();

    return app.exec();
}

Résultat :

Le splash screen peut être arrêté en cliquant dessus.
Après, libre à vous de l'arrêter automatiquement au bout d'un certain temps, il faut juste chercher dans la doc comment faire.

Afficher une icône dans le system tray

Pour certaines applications résidentes en mémoire, il peut être utile de placer une icône dans le system tray, oui là à côté de l'horloge vous savez.

Qt permet justement de le faire avec QSystemTrayIcon :

Le mieux pour apprendre à s'en servir est de jeter un oeil à l'exemple fourni dans la doc de Qt.

Module réseau : utilisez des classes de haut niveau

Dans notre découverte du réseau, nous avons utilisé des QTcpSocket et un QTcpServer. C'est une gestion assez bas niveau des paquets et il nous a fallu apprendre un peu comment le réseau fonctionnait.
On aurait pu parler des paquets UDP aussi, mais on les utilise vraiment dans des cas spécifiques.

En revanche, ce qu'on n'a pas vu, c'est qu'il y a des classes de plus haut niveau qui vous évitent d'avoir à manipuler les paquets TCP directement. Je pense en particulier à :

QHttp : vous permet d'utiliser le protocole HTTP et donc de télécharger des pages web ou des fichiers via le web.
QFtp : vous permet de télécharger et d'envoyer des fichiers par FTP. Vous pourriez créer votre propre client FTP comme Filezilla par exemple.

Ces classes sont beaucoup plus faciles à utiliser que celles que nous avons vues, donc n'hésitez pas à y jeter un oeil.
Elles sont brièvement introduites dans la page d'accueil du module réseau sur la doc de Qt.

Module SQL : accès aux bases de données

Si votre programme doit enregistrer de nombreuses données, il peut être utile de les stocker dans une base de données. C'est un système puissant pour enregistrer des informations, mais il faut connaître le langage SQL pour écrire et lire des informations dedans.

Qt propose tout ce qu'il faut pour se connecter à une base de données dans votre programme, mais il n'inclue pas la base de données... ce sera à vous de l'installer. En clair, si vous utilisez MySQL comme base de données, il faudra d'abord aller installer MySQL sur le site officiel avant de pouvoir établir une connexion avec dans votre programme.

MySQL est un système de gestion de base de données puissant mais évitez d'y avoir recours systématiquement dans vos programmes. Ce serait un peu utiliser un tank équipé de missiles nucléaires pour tuer une mouche.
Parfois, stocker les meilleurs scores dans un jeu pour être facilement fait dans des fichiers (avec QFile par exemple) sous forme de texte simple ou au format XML (je vais en parler un peu plus loin). Inutile de sortir l'artillerie lourde MySQL pour ça.

Si toutefois vous avez vraiment besoin d'une base de données mais que vous ne voulez pas utiliser MySQL qui est un peu gros, jetez un oeil du côté de SQLite qui est tout léger (mais un peu moins complet).

Une fois que vous avez installé votre système de gestion de base de données sur votre ordinateur, vous pouvez découvrir comment y faire appel depuis Qt. Le mieux est de lire l'introduction au module QtSql sur la doc. En tout cas c'est ce que je ferais à votre place.

En quelques minutes de lecture de cette seule page, vous devriez déjà savoir vous connecter à la base de données et exécuter des requêtes SQL (mais attention, il faut connaître le langage SQL avant !).

Module XML : pour ceux qui doivent gérer des données au format XML

Le XML est un langage générique qui est à la base de nombreux autres langages, comme XHTML (qui permet de créer des pages web).

Le principe de XML peut être très vite compris si vous avez déjà fait du XHTML avant. En gros, c'est vous qui définissez vos propres balises :

Code : XML

<bibliotheque>
	<livre>
		<auteur>J.R.R. Tolkien</auteur>
		<titre>Le seigneur des anneaux</titre>
	</livre>
	<livre>
		<auteur>R. Barjavel</auteur>
		<titre>La nuit des temps</titre>
	</livre>
</bibliotheque>

Les données sont placées entre des balises que vous définissez. L'avantage du XML est qu'il est facile à lire (enfin, tant que le fichier n'est pas trop gros ou trop complexe).

Vous pouvez vous servir de cette technique pour organiser vos données dans des fichiers sans avoir recours à une base de données. D'autre part, le XML est un format d'échange devenu courant de nos jours, et il est possible que quelqu'un vous "envoie" des données au format XML que vous devrez traiter dans votre programme.

Pour lire le contenu d'un document XML comme celui ci-dessus (et pour écrire du XML aussi), il y a le module QtXml qui permet de faire cela facilement. Il vous faudra acquérir avant un peu de théorie sur le fonctionnement de XML (DOM, SAX, XQuery, DTD, XML Schema...). Il vaut mieux être rôdé sur la théorie de XML avant de s'y lancer sinon vous n'en profiterez pas.

Je vous conseille de lire cette petite introduction à XML sur le Site du Zéro avant de faire des recherches plus approfondies.
Wikipédia est une bonne source de départ aussi.

Une fois que vous connaissez un peu mieux le fonctionnement de XML, direction la page d'accueil du module QtXml pour découvrir les outils que Qt met à votre disposition pour lire et écrire du XML. Il y a de quoi faire, et encore une fois je vous le rappelle, mieux vaut être armé et connaître XML avant de se lancer là-dedans !

Module Core : toutes les fonctionnalités de base de Qt

Le module QtCore contient des classes de base de Qt qui n'ont pas de rapport avec les GUI et qui peuvent donc être utilisées dans un programme purement console.

Dans ce module, on trouve un certain nombre de classes que vous connaissez déjà :

QString : gestion des chaînes de caractères.
QByteArray : une suite d'octets (on s'en est servi dans le programme de Chat pour construire des paquets).
QFile : accès aux fichiers.
QLocale : permet d'accéder aux habitudes de représentation des nombres et chaînes dans différentes langues.
QList : une liste capable de stocker un tableau à taille dynamique (cette classe est une version "Qt" de ce qui se fait dans la STL dont je vous ai parlé plus haut).
QUrl : représente une URL.

Voilà quelques exemples de classes du module QtCore que vous avez déjà utilisées. Comme vous le voyez, ces classes font partie du "coeur" de Qt et pas du module GUI car elles peuvent être réutilisées dans tous les autres modules.

Jetez donc un oeil à la liste des classes du module QtCore. Il y a de quoi faire, et on retrouve notamment de nombreuses versions "Qt" de classes présentes dans la STL (il y a même un QVector !).

Bonne pêche !

J'espère que cette annexe aura rempli son rôle : vous aider à regarder dans de nouvelles directions. L'inconnu, ça fait un peu peur au début, mais on s'y fait très vite vous verrez.

Comme vous avez pu le voir, tout ce que vous pouvez faire en C++ (et en programmation en général) est tellement riche qu'on n'aurait jamais assez d'une vie pour tout connaître. J'espère que vous me comprenez maintenant.

Plutôt que de tout apprendre, essayez plutôt de découvrir une nouvelle notion à la fois. Si vous vous éparpillez trop, vous aurez du mal à bien assimiler ces connaissances.

Bon courage, et bonne continuation !

Tutoriels

Communauté

Mon compte

Recherche

Livre d'or

Publicité