Les meilleurs livres Qt

Ce livre est bien écrit ; ce qui est le plus appréciable, surtout, c'est le découpage des différentes parties et chapitres choisis par l'auteur. Cet ordre fait que le livre est très compréhensible. Cela va de l'historique de Qt, jusqu'à la publication de son application, en passant par le débogage et les notions principales de Qt (QtWidget, QtCore, QtGui, etc.).

Bien que les copies d'écran soient prises sur un système OS X, l'auteur explique aussi ce qu'il faut pour les autres systèmes, soit Windows et Linux. Notamment, par exemple, pour l'installation de Qt ou pour la publication de son application. Ceci est fort agréable, car n'étant pas du tout un utilisateur de Mac, cela m'aurait beaucoup handicapé de ne pas avoir cette diversité.

Pour ce qui est du contenu, on sent que l'auteur veut amener son lecteur petit à petit, étape par étape, à la compréhension de Qt et ainsi lui permettre de se perfectionner, si besoin est, en sachant exactement où chercher et comment le faire. Autre petite chose, tout est mis en relation avec Qt Creator, l'EDI pour Qt, ce qui est un très bon point, car on apprend à s'en servir, et ce, en même temps que Qt.

Malgré tout il y a quelques petites choses négatives à mon goût, notamment deux points : le manque d'un chapitre sur QML et sur la partie mobile. Sachant que ce sont deux très grosses nouveautés de cette version 5 de Qt, c'est un peu dommage de ne pas les voir dans cet ouvrage. Néanmoins, cela reste un très bon livre que je recommande fortement à toute personne désireuse d'apprendre Qt.

« Maîtrisez Qt 5 » est un livre modulaire conçu pour toute personne désireuse de concevoir des applications avec Qt 5. Il aborde la grande majorité des modules disponibles sous Qt 5 : Qt Core, Qt Network, Qt SQL, Qt GUI, Qt Widgets, Qt Mutimedia, Qt Test, Qt Linguist ainsi que l'optimisation d'application avec Qt. La structure du document est parfaite pour quelqu'un qui souhaite découvrir un module donné. Ce qui est particulièrement intéressant dans le document, c'est le style rédactionnel de l'auteur, simple et compréhensible de tous. Mieux, chaque module est expliqué par des exemples de codes concrets qui permettront aux lecteurs de s'appliquer au fur et à mesure qu'ils évoluent dans la lecture. Par ailleurs, le document introduit quelques notions du C++ (les pointeurs, les copies, les types primitifs, les structures) avant d'enchaîner avec les modules Qt proprement dits. Bien entendu, il ne s'agit que d'une introduction et non d'une initiation au langage C++. Ceci étant, il est nécessaire d'avoir au moins le niveau intermédiaire en langage C++ avant de se lancer dans l'apprentissage de ce livre.

Le chapitre le plus détaillé de « Maîtrisez Qt 5 » est sans doute celui sur le module Qt Core et fondations. En effet, l'auteur a pris le temps d'insérer tout ce qu'il faut dans ce chapitre : la structure des objets de Qt, les signaux et les slots, la synchronisation des algorithmes, les threads, les pointeurs, la classe QString, etc. En plus des explications fournies sur la classe QString, le livre finit par une optimisation du code avec les classes QByteArray et QStringRef. Le module Qt Core est la base même du développement applicatif avec Qt. Maîtrisez cette partie de Qt et le reste sera simple à assimiler. Au niveau du chapitre sur Qt GUI, vous pourrez découvrir le rendu 2D (les classes QPainter, QPainterEngine, QImage, QPixmap, QPainterDevice et leur arborescence) et une courte introduction du rendu 3D avec OpenGL. Le chapitre sur Qt Widgets donne tout le nécessaire pour réaliser facilement et rapidement son interface graphique avec Qt Designer ; il explique également le modèle-vue ainsi que la disposition des composants graphiques avec les layouts. Enfin, si vous avez envie de concevoir des applications multilangues avec Qt, ce document vous apprend à le faire avec Qt Linguist.

Comme complément, l'auteur fait une généralité sur les types de licences pour vos applications, parle du Qt Installer Framework afin de concevoir des installeurs universels pour vos applications de même que des dépendances auxquelles il faut faire attention lors de la publication d'application.

Cependant, j'aurais aimé que l'auteur introduise des chapitres sur Qt Quick et Qt Mobility. J'espère que cela sera fait pour les prochaines éditions afin que le livre soit presque complet. Les nouvelles fonctionnalités majeures introduites avec Qt 5 concernent ces deux parties manquantes. Toutefois, « Maîtrisez Qt 5 » demeure un livre idéal pour l'apprentissage de Qt.

Cet ouvrage est destiné à un public initié au C++, tout en restant destiné essentiellement à des débutants. Les fondamentaux du langage doivent être maîtrisés pour aborder sereinement les exemples fournis par l’auteur. Seul un rappel sur le mécanisme de copie et sur le fonctionnement des « smart pointers » est effectué.

Le découpage choisi par l’auteur semble tout à fait pertinent. En effet, en abordant les modules dans un ordre proche de la progression des niveaux d’abstraction associés (de Qt Core, Qt Network jusqu’à Qt Widgets et enfin Qt Multimedia), le lecteur pourra se familiariser avec le fonctionnement du framework avant d’aborder les concepts liés au découpage de l’architecture des applications.

Par ailleurs, tout est structuré autour de l’utilisation de Qt Creator, un EDI spécialisé pour Qt, qui sera probablement utilisé par tous les nouveaux arrivants.

Seul bémol, l’aspect Qt Quick (et donc QML) n’est pas abordé… ce qui limitera la portée de l’ouvrage à des plateformes « desktop ».

« Créer des applications avec Qt 5 » est un livre modulaire écrit par des membres réputés de Developpez.com. Ils ont concentré leur expertise afin de réaliser un livre de qualité nous permettant de nous plonger dans Qt 5. Même si le titre est généraliste, le livre se focalise sur l'apprentissage de QML et Qt Quick. Ainsi, après une présentation de la bibliothèque et de ses outils, une explication pour les développeurs souhaitant migrer de Qt 4 à Qt 5 et un exemple d'une application graphique interagissant avec un service Internet, vous trouverez une explication détaillée de Qt Quick et QML, menant à la réalisation de plusieurs applications (un outil de mixage, un éditeur de texte et une application communiquant avec un serveur pour afficher le temps). Cette description débute avec une revue du langage QML et JavaScript. Ensuite, chacun des éléments de Qt Quick est expliqué, permettant de comprendre les bases de la conception d'une interface graphique. Bien entendu, il explique aussi comment lier son interface Qt Quick avec un code C++ et comment lui permettre de communiquer avec Internet. Cette section se conclut sur les différents outils d'analyse et de débogage de l'application. Finalement – et cela peut être étrange – le livre conclut sur une arborescence graphique de l'utilisation du disque dur en utilisant le framework QGraphics View (donc, sans QML). En somme, le livre offre un bon aperçu de Qt 5 et une excellente introduction à Qt Quick. Le livre cible les développeurs souhaitant se plonger dans Qt Quick et le QML ou les designers amenés à créer une interface dynamique avec le langage déclaratif, et cela, sans pour autant apprendre à utiliser du code C++.

En conclusion, ce livre est parfait pour se familiariser doucement avec Qt 5, mais surtout, pour apprendre la conception d'interfaces avec Qt Quick, élément essentiel des applications graphiques portables et modernes.

Comme son nom l'indique, ce livre est à destination des développeurs Qt confirmés ayant déjà une bonne connaissance du framework. Il ne détaille aucun concept de base de Qt assumant que ceux-ci sont déjà acquis par le lecteur, il part cependant de zéro dans l'explication des concepts avancés comme la programmation modèle/vue ou graphique/vue. Il est plus que conseillé de lire d'abord C++ GUI Programming with Qt 4 ou d'avoir une bonne expérience de la programmation Qt avant de se lancer dans cette lecture. Il est cependant un très bon complément pour les développeurs souhaitant aller plus loin dans le développement avec Qt. Il est construit principalement autour d'exemples que l'on suit tout au long d'un chapitre.

Critique détaillée des différents chapitres

Le premier chapitre décrit pour la première fois dans un livre l'utilisation du module QtWebKit. La première partie est assez simple et reprend l'exemple d'un navigateur Web pour décrire l'utilisation des classes du module. La seconde partie devient très intéressante avec une explication de l'intégration de QWidget dans une page Web permettant ainsi de créer une application hybride.

Le second chapitre présente les fonctionnalités multimédia de Qt avec un exemple rapide de ce qu'on peut faire avec QSound et QMovie, puis toute une partie très détaillée sur l'utilisation de Phonon pour créer un lecteur de musique et un lecteur vidéo. Il est un peu décevant que QtMultimedia qui est apparu dans Qt 4.6 ne soit cité qu'en conclusion de ce chapitre. Il est clair qu'il s'agit de fonctionnalité de plus bas niveau en comparaison de Phonon qui permet une manipulation simple des flux audio et vidéo, mais ce dernier a de grande chance de ne plus être supporté dans les prochaines versions de Qt au profit du module Multimedia de Qt Mobility, il est donc surprenant de voir deux sous-chapitres entiers dédiés à celui-ci.

Les chaptires trois à six décrivent l'intégralité de l'architecture modèle/vue de Qt introduite dans Qt 4.4. Il s'agit de la partie la plus difficile de ce livre (peut-être également la plus compliquée du framework Qt) même si Summerfield part des bases de la programmation avec ce modèle. Les deux premiers chapitres se basent sur un exemple d'une application de codes postaux alors que les deux chapitres suivants décrivent le développement d'une application de liste des tâches avec une gestion du temps (timer). Même si une grande partie de la documentation est reprise ici, pour les développeurs voulant utiliser la programmation modèle/vue, ces chapitres sont plus qu'appréciables pour bien comprendre le fonctionnement interne de cette architecture.

Les chapitres sept et huit concernent le threading dans les applications Qt. Le chapitre sur le module QtConcurrent est très intéressant, appuyé d'un exemple d'application de traitement d'images (conversion de format) détaillant le filtering et le mapping entre autres. J'ai cependant été très déçu du chapitre sur QThread. Je suis un fervent lecteur des Qt Labs Blog et j'apprécie le travail d'écriture concernant l'utilisation de certaines parties du framework Qt un peu obscures. J'avais particulièrement été en accord avec le sujet "Vous vous y prenez mal..." et ce chapitre présente un exemple qui fait exactement le contraire de l'explication, à savoir sous-classer QThread et mettre le code de ce que l'on veut threader dans la fonction run(). Cela montre un manque de cohérence entre les créateurs du framework et les personnes qui écrivent la documentation et les livres, ce n'est pas la première fois que je le remarque, je trouve ça dommage.

Le chapitre neuf explique comment créer un éditeur de texte riche en utilisant principalement QTextDocument et QTextCursor. Il détaille également la manière d'ajouter l'auto-complétion et la colorisation syntaxique dans un tel éditeur. Ce chapitre est très bien fait et je le conseille à tous ceux qui veulent rendre la saisie de texte plus agréable dans leur application.

Le chapitre dix se concentre sur l'exportation et l'impression de documents dans différents formats. Il commence avec une comparaison de la qualité des différents modes d'exportation et d'impression pour différentes plateformes et versions de Qt. Puis une explication détaillée des différentes méthodes pour exporter des documents dans les formats ODF, HTML, PDF, PS et SVG est présentée ce qui est une première pour Qt et très intéressante.

Les chapitres onze et douze présentent l'architecture graphique/vue apportant une grande valeur ajoutée à ce livre étant donné qu'il s'agit d'une partie du framework la plus utilisée par les développeurs Qt. Les chapitres s'articulent autour de deux exemples bien choisis permettant de faire un tour de l'ensemble des fonctionnalités de base de l'architecture graphique/vue. Pour une utilisation complexe avec détection de collision par exemple, il faudra revenir.

Le chapitre treize décrit lui aussi pour la première fois une nouvelle partie de Qt 4.6 : le framework animation et la machine à état. Ce chapitre est bien fait commençant vraiment du début pour un nouveau concept dans Qt mais il s'agit vraiment d'une introduction et on aurait aimé que ça aille un peu plus loin. Il s'agit peut être également de la déception du fait que c'est la fin du livre.

Avis général

Malgré les critiques que j'ai pu émettre sur différents chapitres, il s'agit néanmoins d'un très bon ouvrage à mettre dans toutes les bibliothèques des développeurs Qt confirmés. De nombreux encadrés détaillant très précisément un aspect du framework (MIME types, magic numbers, smart pointers, etc.) sont très apréciables, et il m'arrive régulièrement d'aller m'y référer. Le seul point que je trouve regrettable est le manque de consistance avec les sujets des Qt Labs Blogs, mais il peut s'agir d'un problème de temporalité entre les écritures et du fait que le nombre de développeurs du framework est devenu très important. Qt est en effet un framework qui évolue très vite et on peut se demander quelle est la durée de vie d'un tel livre. Je trouve tout d'abord que pour un livre ayant été écrit avant la sortie de Qt 4.7, il y est fait régulièrement référence en présentant comment ce sera dans cette nouvelle version ce qui favorise une durée de vie plus longue. Le côté un peu négatif pour celle-ci est sûrement les parties sur Phonon mais également les quatre chapitres sur l'architecture modèle/vue qui, selon certaines rumeurs, risquent de ne pas être supportée encore très longtemps. Il faut relativiser en soulignant que réaliser un livre avec une durée de vie importante pour un framework qui bouge à la vitesse de Qt est très difficile.

La valeur de ce livre est expliquée dans l'introduction qui détaille l'histoire du développement Symbian à ce jour, tout en sous-estimant légèrement la gravité des problèmes qui font que Qt est une évolution plus que bienvenue.

Le public visé est : toutes les personnes intéressées par l'utilisation de Qt pour développer des applications Symbian, des débutants à ceux déjà experts dans le domaine de Symbian ou de Qt. L'introduction suggère même des chapitres qui peuvent être ignorés par les lecteurs plus expérimentés. Toutefois, de mon point de vue, il serait plus avantageux de lire ce livre comme il est censé être lu - chapitre par chapitre et leçon par leçon, sans en sauter. Il y a six chapitres, chacun avec environ 10 leçons et tout le monde doit commencer au moins par le 3e, Qt in General, qui traite des aspects de Qt qui ne s'appliquent pas spécifiquement à Symbian et révèle les points forts de la plateforme qui pourrait être autrement moins évidents, tels que le datatype QVariant et les API Qt pour les threads et la connectivité.

Bien que ce livre n'est certainement pas pour les inexpérimentés - la connaissance de C++ et de développement mobile est souvent supposée - il y a quand même des leçons exceptionnellement utiles sur certains concepts de base ; la gestion de la mémoire, par exemple, et la communication entre threads. Il convient cependant de noter que le style narratif obscurci parfois des passages utiles, ce qui nécessite une lecture attentive de ceux dont la langue maternelle n'est pas l'anglais.

Le chapitre 4 est la raison du pourquoi tout le monde a besoin d'acheter ce livre. Il couvre ce qui fait de Qt une plateforme viable pour Symbian - les « Mobility API », y compris la gestion des contacts, la géolocalisation, la messagerie et plus (sans s'attaquer à certains des inconvénients, comme le fait que l'émulateur ne supporte aucun de ces éléments). Les chapitres 5 et 6 essayent de satisfaire des ambitions non atteintes dans le chapitre 4, laissant loin derrière Qt fondation. Le livre se résume sous la forme de plusieurs exemples, très bien réalisés et téléchargeables.

Ce qui manque le plus au livre est un chapitre de dépannage. Tous les livres de technologie devraient en avoir un, mais pour un livre sur le développement Symbian c'est indispensable. Les causes possibles pour une application de refuser de compiler, de s'installer ou de s'exécuter sont légion, même les applications développées avec Qt, et ce livre aurait bénéficié considérablement de s'attaquer à certaines d'entre elles. En effet, le seul vrai défaut de Qt for Symbian est un optimisme débordant et, par conséquence, une incapacité à reconnaître les aspects négatifs de développement Symbian. Particulièrement, je me demande combien de temps il peut être pris au sérieux en tant que plateforme mobile en concurrence avec Android, iPhone et le nouveau système d'exploitation fleuron de Nokia, Maemo.

Cette seconde édition de cet ouvrage de référence sur la programmation d'interfaces graphiques avec Qt a été construite à partir de la première édition, y ajoutant un certain nombre de chapitres ainsi que les fonctionnalités intégrées au framework Qt dans les versions 4.2 et 4.3. Bien qu'il ait été écrit il y a un peu plus de deux ans au moment de la critique, il reste un livre de référence qui permet d'acquérir les bases du framework au cours de la première partie et d'en approfondir certaines spécificités au cours des parties II et III. Je le conseille, entre autres, à toute personne voulant commencer la programmation avec Qt.

Si vous avez déjà lu la première édition, vous pourrez découvrir un nouveau chapitre sur la personnalisation d'applications avec les feuilles de style et QStyle ainsi qu'un chapitre consacré à QtScript. Les chapitres sur la 2D et la 3D ont été séparés, ce qui permet d'aller plus en profondeur dans les deux domaines notamment avec l'utilisation d'OpenGL couplée avec QPainter dans le chapitre 20. Cependant, la structure générale du livre reste la même, il serait donc peut-être plus économe de retrouver ces informations sur la documentation officielle.

Cette nouvelle édition comporte également une nouvelle annexe sur Qt Jambi, le port de Qt pour Java, qui n'est aujourd'hui plus supporté par Nokia et donc relativement peu utilisé. Un certain nombre de fonctionnalités du framework peuvent sembler manquantes à ce livre, car elles étaient en grande partie absentes au moment de la rédaction. Je pense notamment à QtWebKit, toute la partie multimédia avec Phonon et les classes de Qt, l'architecture graphique/vue et le framework animation. L'ensemble de ces nouveautés est cependant disponible dans l'ouvrage Advanced Qt Programming paru en juillet 2010.

Contrairement à la première édition et à sa traduction française, ce livre est toujours disponible à la vente.

Il est possible que je ne sois pas totalement objectif dans cette revue, étant donné que je suis « émotionnellement impliqué » dans un autre ouvrage Qt, j'ai cependant fait de mon mieux pour rester dans l'objectivité en montrant ce que j'ai apprécié et ce que je n'ai pas aimé à la lecture du texte.

Premières impressions

La première chose que j'ai faite après avoir déballé le livre a été de regarder la quatrième page de couverture et de voir qui était l'auteur (je l'avoue, je n'avais jamais entendu parler de Daniel Molkentin avant). Il est développeur de KDE depuis 2000, il se concentre sur le module PIM du framework. Quand ce livre a été écrit (vers 2006), l'édition de KDE basée sur Qt 4 n'en était qu'à ses prémices, j'espérais donc de Daniel qu'il ait une bonne connaissance globale de Qt sans nécessairement aller dans les détails - il était des bêta testeurs de Qt4, je doute cependant qu'il ait vérifié toutes les parties que cette version cachait.

Ensuite, j'ai regardé l'avant-propos. Il y en a deux : un par Eirik Chambe-Eng, l'autre de Matthias Ettrich. Ces noms parlent d'eux-mêmes et étaient très positifs quant au travail de Daniel, ma soif n'a fait qu'augmenter. Aussi, Axel Jaeger, un administrateur de QtCentre, est mentionné comme étant une des personnes ayant une certaine influence sur le livre, ce qui était un plus non négligeable (le site est mentionné de nom également).

En détail

Le livre débute en expliquant les concepts de base de Qt, les différences entre les classes qui héritent de QObject et les autres (certains pensent que toute classe de Qt est un QObject). Vient ensuite un chapitre agréable expliquant Qt Designer dans tous ses états. Une très bonne chose pour les nouveaux utilisateurs. Le seul problème que j'y vois est que le concept des layouts est expliqué de façon assez éparse dans tout le livre au lieu de l'être dans le chapitre séparé (très bien aussi) où il est décrit, même si des traces apparaissent au début du livre (des sections similaires partageant le même nom).

Tout d'abord, il n'y a pas un seul mot concernant le framework Graphics View, ce qui est relativement étrange. Au début, je pensais que le livre avait été achevé avant l'apparition de ce framework (dans Qt 4.2.0). Cependant, quand j'ai remarqué que l'auteur mentionnait Qt 4.2 à d'autres endroits, ça n'était pas plausible. Ce framework est une partie très importante de Qt, fortement utilisée par ses utilisateurs : j'aurais espéré que ce livre décrive au moins ses bases ! C'est un grand moins.

Ensuite, mon sous-système de Qt favori - Interview, le framework modèle-vue. Le livre décrit agréablement les bases de son utilisation et essaye ensuite de couvrir des sujets plus avancés, comme l'implémentation de ses propres modèles. Des problèmes apparaissent quand Daniel tente d'expliquer les délégués, une partie très importante du framework. La section sur les délégués ne fait que trois pages et ne décrit qu'un des usages les moins fréquents - créer son propre éditeur de widgets et échanger des données avec le modèle. Il n'y a pas un seul mot sur le dessin d'items ou la gestion des événements pour les index de modèles. Il manque aussi au chapitre la manipulation des vues elles-mêmes (qui viendrait complémenter les sections sur l'implémentation des modèles et délégués).

Du côté clarté, le livre explique des sujets comme le compositing et la sérialisation d'objets, même s'il ne fait que de brèves mentions des capacités réseau de Qt et ignore complètement le framework de test unitaire.

Conclusions

J'ai rencontré bien des petites fautes et incohérences à la lecture, dont quelques-unes sont ici mentionnées, partiellement et probablement causées par une traduction imprécise (je pense que le livre a été écrit à l'origine en allemand) et partiellement, probablement par l'expiration du délai - il semble que des parties du livre aient été taillées.

Le livre traverse les sujets de base de la programmation avec Qt mais ignore quelques concepts plus avancés. Ce qui m'a le plus manqué : le framework Graphics View, le test unitaire et des sections plus avancées sur le modèle-vue. J'aurais aussi aimé voir plus de sujets avancés mais ce n'est pas une lacune rare dans les livres sur Qt 4. Même si le livre n'est pas parfait, il est quand même une fontaine de connaissances pour les programmeurs qui débutent avec Qt.

J'attends avec impatience la seconde édition, je suis sûr que tous ces problèmes seront corrigés, nous aurons alors un excellent livre pour apprendre.

Le K Desktop Environment (KDE) est développé sur base du framework graphique Qt. Qt est cependant plus qu'un set de widgets : il a évolué sur les dernières années pour devenir un environnement de développement d'applications multiplateformes avec un bon nombre d'outils et de bibliothèques utilitaires. The Book of Qt 4: The Art of Building Qt Applications, de Daniel Molkentin, publié par No Starch Press, décrit minutieusement en exquis détails les widgets principaux, les algorithmes et les bibliothèques utilitaires (comme les outils tels que Qt Designer) nécessaires lors du cycle de développement de l'application.

Ma première impression est que ce livre offre une introduction solide au développement d'applications avec interface graphique en utilisant le framework Qt. Grâce à sa cohérence, il est bien prévu pour une utilisation future en tant que livre de référence basique et instantané, hébergé potentiellement dans toute bibliothèque de programmeurs C++.

Le contenu

Avec 14 chapitres, 440 pages et deux appendices, le livre, assez digérable, de Daniel Molkentin prend le temps nécessaire pour détailler les widgets pertinents, les algorithmes et les outils nécessaires pour mener à bien un projet Qt.

Le livre, construit systématiquement sur le détail précédent, débute avec une application Hello world et explique moult outils basiques, dont Qt Designer. Il touche aussi des sujets comme les layouts, les événements, les connexions aux bases de données, le parsing XML, les graphiques, les différents widgets et l'internationalisation. Tous les sujets intéressants sont introduits... et immédiatement développés.

Le chapitre 10, couvrant la bibliothèque graphique Arthur, est mon préféré. Il explique comment générer des PDF, offrir un support du SVG et comment dessiner des widgets. J'ai particulièrement aimé la section 10.9.3, où un fichier PDF a été généré très simplement en configurant correctement un objet QPrinter.

Pour qui est ce livre ?

Ce livre est prévu pour les programmeurs C++ qui aimeraient connaître le potentiel de la bibliothèque Qt et peut-être utiliser les outils d'IHM pour un projet spécifique.

Pertinence du logiciel libre

Actuellement, Qt est distribué sous licence QPL. Précédemment, cette approche open-source n'a pas été entièrement pure et le projet KDE a laissé, sur son site Web, une page le spécifiant, pour des raisons historiques. Trolltech, la société derrière Qt, a essayé de différencier les utilisateurs commerciaux et non commerciaux. Cependant, j'ai vraiment l'impression que le cœur de Trolltech a toujours été orienté en droite ligne de l'open-source.

Les différents sites Web des projets KDE affichent publiquement qu'ils croient que Qt est le meilleur framework disponible pour UNIX. Un framework graphique correct doit permettre, même aux débutants, de construire des applications puissantes et complexes sans devoir avoir un bon niveau en C++ ou de construire les classes utilitaires personnalisées pour des tâches standards comme la gestion du XML ou la connexion à une base de données. Qt est très bien pensé et est un solide exemple d'un tel framework.

Le livre est très lisible et, par conséquent, abaisse la barrière d'entrée au framework Qt encore plus. Plus elle sera basse, plus il sera probable que les développeurs vont rapidement comprendre et commencer à construire de nouvelles et intéressantes applications.

Avantages

C'est un livre solide pour les développeurs C++ intéressés par la construction d'applications efficaces basées sur Qt. Il a aussi sa place en tant que livre de référence pour des visites ultérieures.

Inconvénients

Une critique triviale : un chapitre supplémentaire sur les différences entre les plateformes aurait été utile. Par exemple, il manque des astuces spécifiques à Mac OS X, Windows et UNIX.

Cette critique est disponible sous la licence Creative Commons License 3.0 Attribution-NonCommercial-Sharealike.

Ce livre possède deux aspects très positifs. D'une part, il constitue une petite référence en ce qui concerne Qt 4, de par les nombreux exemples et les nombreuses explications qui y sont présents. D'autre part, il s'avère très efficace si l'on ne s'est jamais intéressé à la programmation d'interfaces graphiques en C++. En effet, ce livre présente un certain nombre de concepts importants, présents dans toute bibliothèque de création d'interfaces graphiques, mais aussi comment ces concepts ont été mis en oeuvre dans Qt 4.

De plus, le livre traite aussi les sous-bibliothèques de Qt non graphiques, sans trop s'y attarder toutefois. On y retrouve donc des introductions aux modules de réseau, de programmation multitâche, d'interaction avec des bases de données, entre autres.

Enfin, il faut préciser qu'il est écrit dans un style très agréable, que le code est clair mais également qu'il y a régulièrement des images, captures d'écrans ou schémas pour étoffer l'explication d'une notion. C'est donc un livre qui vous plonge dans l'ambiance Qt 4, mais qui ne tient pas du tout le rôle de référence. Toutefois, la combinaison de ce livre avec la documentation officielle peut s'avérer très efficace lorsque vous réaliserez des applications avec Qt 4.

De plus en plus, les frameworks dits « portables » comme le Qt font leur place dans le développement d'applications sur divers systèmes du marché. Le livre Qt 4 et C++ : Programmation d'interfaces GUI montre comment développer en utilisant le framework Qt avec le langage objet C++. Le livre est clair et précis, il montre, avec des petits projets, comment arriver à une interface opérationnelle et conviviale, ce qui le rend très agréable à lire et surtout facile a comprendre. On trouvera également une petite partie à la fin du livre qui reprend les bases du langage objet via le C++ et le Java.

Le livre dispose également d'un cd-rom qui contient les exemples (sources) du livre, ainsi que le framework Qt pour Windows, Linux et Mac en version 4.1.x.

Pour finir, ce livre est un bon guide que je recommande à toute personne s'intéressant au développement d'applications portables ou aux personnes voulant créer une interface rapidement à partir de rien.

Voilà un bon ouvrage pour se lancer dans la programmation d'interfaces graphiques portables en C++. Que vous soyez débutant avec Qt ou bien développeur confirmé, ce livre vous sera d'une aide précieuse pour appréhender les nombreux concepts de Qt 4.1, les plus simples comme les plus complexes.

Le début du livre est résolument destiné aux développeurs n'ayant jamais utilisé Qt, les concepts de base y sont détaillés, pour vous amener à créer une première interface graphique. La seconde partie est axée sur les concepts nécessaires pour développer une réelle application fonctionnelle et la dernière partie se focalise sur la programmation plus spécifique et moins grand public comme l'internationalisation d'une application ou la programmation multithread.

Il existe peu de livres sur Qt en français mais celui-ci en est assurément un bon. À la fois livre de référence mais aussi livre didactique, vous y trouverez forcément votre compte, quel que soit votre niveau. Bien qu'étant un puissant framework, Qt apparaît beaucoup plus simple avec un tel livre, clair et bien expliqué.

Simple, abordable et complet, voici le résumé de ce livre. Séparé en trois parties, ce livre est progressif et va relativement en profondeur.

La première partie est dédiée à ceux qui ne connaissent rien de Qt, il y est question des connexions, des signaux et slots, si chers à Qt. Rien qu'avec cette partie, on est capable de créer une interface graphique simple, efficace.

La deuxième partie permet d'aller plus loin en termes de fonctionnalités dans une application. Il est vrai que souvent, on a besoin de plus que simplement une interface graphique permettant d'exécuter un travail puis de redonner la main, sans voir un résultat. Même pour des interfaces simples, Qt simplifie le travail à l'aide des layouts, mais on y voit aussi la gestion des évènements, la gestion du moteur 2D - on regrettera l'absence de Graphics View qui n'est apparu qu'à la version 4.2, au moment de la sortie du livre, mais on ne peut pas tout avoir -, l'architecture model/view très bien pensée même si difficile à première vue d'utilisation, les conteneurs maison, la gestion du réseau des bases de données, de l'XML...

La dernière partie est dédiée aux traductions - Qt propose un système simple pour traduire son application -, au multi-threading, aux plug-ins et aux spécificités de chaque plateforme. On appréciera aussi le mot au sujet de Qtopia.

En définitive, pour qui ne connaît pas en détail Qt 4, ce livre est indispensable même si déjà dépassé par la nouvelle version de Qt 4 qui ajoute des fonctionnalités. Mais le livre est didactique, on sent la main de l'auteur de la documentation officielle de Qt, Mark Summerfiled et c'est un gage de sérieux et de qualité.