Note : 0 ; A éviter à tout prix !

Si vous cherchez dans cette sélection un livre à éviter à tout prix, vous venez de le trouver. L’auteur est probablement un bon programmeur, d’ailleurs il nous vomit des pages de code pour expliquer des choses qui seraient mieux mises en valeur sur 4 ou 5 lignes, mais il est sans aucun doute un exécrable pédagogue. Sans compter que l’auteur semble imaginer que l’on utilise les STL que pour stocker des entiers ou des flottants : les exemples se cantonnent exclusivement à cela ! Les explications sont souvent confuses et incomplètes.

Le livre ne commence sérieusement qu’avec le chapitre 3. Les deux précédents nous ont surtout servi à appréhender la pauvreté de l’expression écrite que nous aurons à subir durant le reste de l’ouvrage. Donc ce chapitre 3 sert de base pour le reste du livre, bases qui sont sans connexion directe au sujet (l’auteur pense que nous sommes assez suicidaires pour nous servir de ce texte comme base de notre savoir en C++). On y évoque de manière décousue les templates, les exceptions et surtout la bibliothèque iostream. Le tout décousu à l’envie.

Le chapitre 4 est curieusement appelé « organisation de la librairie C++ : il s’agit d’un listing des headers de la librairie C++ et d’une pseudo-description sur 3 pages de la classe string, avec un magnifique diagramme de Booch dont les éléments sont positionnés avec une précision d’un demi-centimètre !

Continuer à lire « Note de lecture : La bibliothèque standard STL du C++, par Alain-Bernard Fontaine » →

Note : 4 ; Ni bon ni mauvais, juste alimentaire… et dépassé !

Encore un bouquin pour ceux qui veulent passer au C++ ! Celui-ci accuse 20 ans et se présente sous la forme d’un texte de 350 pages découpé en … 4 chapitres. Nous avons donc une belle moyenne de près de 90 pages par chapitre. Ca se présente mal. Voyons ce qu’il en est « en vrai ».

Le premier chapitre n’en est pas un. C’est plutôt un avant-propos qui nous souhaite la bienvenue sur 3 pages.

Le second chapitre est déjà plus conséquent avec ses 90 pages. Il aborde C++ en tant que « C avancé ». Et c’est vrai que l’on y parle pas beaucoup de C++ ! On y montre beaucoup d’éléments du langage C avec quelques spécificités du C++ comme les références les nouveaux types de cast ou des fonctions de la librairie standard C++. Mais de classes, point (par exemple). J’ai bien aimé les courts exemples pour illustrer les concepts.

Continuer à lire « Note de lecture : Langage C++ seconde édition, par Nino Silverio » →

Note : 7 ; De bons conseils d’experts pour ceux qui pratiquent déjà le C++. Moins indispensable que les 2 livres de Scott Meyers.

Ce livre fait partie de la série d’ouvrages dont fait également partie “Effective C++”, qui constitue chacun des avis d’experts sur le développement en C++. Dans son volume, Tom Cargill s’attache à prodiguer des conseils sur la conception des classes en C++ : surcharge d’opérateur contre fonction membre, utilisation de l’héritage, etc… Il adresse donc des préoccupations différentes de celles de Scott Meyers. Un aspect non négligeable est la relative concision du texte qui noircit juste un peu plus de 220 pages avec une proportion de code je pense un peu supérieure à 30%. Le contenu, justement est divisé en 9 chapitre, le 10ème étant un résumé des règles établies au fil du texte.

Le premier chapitre couvre la notion d’abstraction. C’est réellement un fondamental de cet aspect de la conception, dans le principe indépendant de C++, mais illustré avec C++. Le second complète harmonieusement le propos en traitant de la consistance. Une approche intéressante qui consiste ici à s’intéresser à différentes facettes de la consistance d’une classe : contractuelle, sémantique et physique. Je mets dans le même lot de chapitres ayant d’avantage trait à la conception qu’au C++, le chapitre 3 traitant de « l’héritage inutile ». En gros, ce sont les cas où la délégation est préférable à l’héritage. Un chapitre un tout petit peu plus faible que les deux précédents.

On est d’avantage dans le C++ au chapitre 4 qui évoque les méthodes virtuelles. C’est un peu brouillon, difficile de voir où l’auteur veut en venir, Mais les conseils sont valables. J’ai préféré le chapitre 5 qui couvre la surcharge d’opérateurs, sujet délicat s’il en est.

Retour à des questions de conception au chapitre 6 qui est dédié au wrapping, en l’occurrence l’enrobage de familles de fonctions C dans des classes. Un sujet qui m’était important à l’époque et très bine traité ici.

Arrivée au choses sérieuse au chapitre 7 : l’efficacité. Un chapitre hélas un peu moins palpitant que ce que j’aurais escompté : ça tourne beaucoup autour de l’allocation dynamique, sur un cas d’étude « BigInt ». Les 35 pages de l’étude de cas qui suit ne sont pas mes préférées du livre. Un peu comme au chapitre 4, je ne vois pas trop où on veut en venir. Par contre le chapitre 9 sur l’héritage multiple est à lire absolument : il permet de bien appréhender les subtilités des différents cas de figure où l’héritage multiple peut vous entrainer.

C’est un livre moins indispensable que le Scott Meyers, mais d’une lecture agréable. Une des originalité du format de Tom Cargill est de proposer en fin de chapitre des références bibliographiques pour approfondir les sujets, et des exercices (hélas, sans les corrections). Comme je l’ai dit, le texte est concis : le lecteur non marathonien peur en venir à bout en une semaine ou deux. Si l’on peut s’estimer déçu en premier abord, je pense que ce texte permet surtout de renforcer les fondamentaux. A ce titre, c’est une très bonne lecture.

Référence complète : C++ Programming style – Tom Cargill – Addison Wesley 1992 – ISBN: 0-201-56365-7

http://www.goodreads.com/book/add_to_books_widget_frame/0201563657?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note : 5 ; Une source d’information sur les Iostreams moins médiocre que le Teale. Vaut le détour (même si le sujet aurait pu être mieux traité) pour la bibliothèque GDI développée à base de streams !

Très déçu par le médiocre « C++ iostreams handbook » et vu la rareté des ouvrages sur le sujet, il ne m’a pas fallu à l’époque beaucoup de temps pour m’intéresser à celui-ci : il ne pouvait qu’être meilleurs ! En fait, il s’est surtout avéré très différent !

On pourrait appeler ce livre “variations sur les iostreams”. Les auteurs abordent le sujet en développant une bibliothèque iostream pour la GDI Windows. Voyons de plus près le contenu.

Le texte principal de l’ouvrage couvre 300 pages. A hauteur de 10 chapitres, cela nous fit une moyenne un peu élevée de 30 pages par chapitre, mais il faut tenir compte de la proportion importante de code. Il ne faut pas non plus oublier les annexes qui ne sont pas anecdotiques, car elles tiennent 70 pages.

Entrée en douceur pour ce premier chapitre qui présente le concept de streams en commençant par exposer son équivalent avec la bibliothèque C. Bien sur les iostreams sont comparées (aventageusement) par rapport à cette approche et on termine sur quelques perspectives qui annoncent les chapitres futur. Peu de code pour cette introduction de 33 pages, du texte qui se laisse lire, essentiellement.

Le but des 30 pages du chapitre est de faire le lien entre l’approche orienté objet et la bibliothèque iostream. Ce n’est pas tellement réussi et je pense qu’il aurait fallu simplement faire l’impasse sur la description du modèle objet. Les concepts en sont connus du public visé par le texte.

Heureusement les 80 pages du chapitre 3 vient à la rescousse. C’est sans conteste le chapitre le plus utile du livre pour comprendre la librairie iostream, du moins l’ancienne, celle d’avant le standard 98. La structure et l’architecture de la librairie sont très bien expliqués. En fait, c’est la première référence que jai l’heur de croiser qui m’ait apporté une telle clarté. Par contre les détails sont expliqués sinon moins clairement, du moins plus laborieusement.

Les chapitres 4 et 5 nous offrent des interludes d’une dizaine de pages chacun. Le premier pour expliquer simplement le mécanisme de friendship qui permet d’étendre la librairie iostream de manière externe. Le second pour nous présenter un autre concept clé de la librairie : les manipulateurs. C’est mieux fait que dans le Teale, mais hélas encore une fois un peu court.

Etendre la librairie iostream afin de permettre de manipuler les devices graphiques Windows comme des streams est le véritable objectif du livre ! C’est ce qui est abordé dans les 4 chapitres suivants. Le chapitre 6, le premier d’entre eux est là pour expliquer le mécanisme d’évolution de la librairie iostream sur la base des classes ios et streambuf. Hélas c’est loin d’être claire et franchement abstrait. Et bien entendu c’est aussi un pau à réviser avec la norme.

Les 35 pages du chapitre 7 ont pour objectif d’aborder le wrapping des GDI Windows et OS2 en iostream. La plus grande partie de ce chapitre est consacrée à en expliquer le fonctionnement. Il finit par aborder timidement l’implémentation d’une classe de wrapping : textspace (qui étends ostream).

Ce sont 45 pages qui cette fois sont consacrées à la classe ioscontext qui étends ios, au chapitre 8. Ce chapitre est construit sur le même modèle que le précédent.

Le chapitre 9 consacré aux Blobstreams aurait été fort intéressant s’il était allé jusqu’au bout du propos, à savoir l’implémentation sous forme d’extention de la librarie iostream. Mais il fait un boulot décent à présenter les différents formats images et son.

Un peu à part, le chapitre 10 nous présente le wrapping de la gestion du port série RS 232C sous forme d’iostream. C’est original et intéressant (bien que l’on utilise plus guère cette norme). Mais on est hélas frustré car le chapitre ne va pas au bout de la question.

Les annexes, quoi que volumineuses ne s’avèrent guère utiles. Les deux premières expliquent la notation graphique bizarre utilisée tout au long de l’ouvrage, tandis que la troisième se veut un guide de réfernce de la librairie iostream. A l’usage elle ne s’avère guère opérationnelle.

Au final se livre cherche à atteindre 2 cibles :

• Faire comprendre la librarie iostream. Cet objectif est plutôt bien atteint par la première partie du livre. En tout cas, c’est mieux que le Teale !
• Présenter une étude de cas de librarie utilisable sous forme d’interfaces stream. C’est original et même très intelligent et pourrait servir de source d’inspiration pour bon nombre de librarie. Mais le livre est un peu court sur le volet pédagogique pour expliquer la construction de la librarie. Il se noie dans pas mal de sujets connexes comme l’explication de la GDI.

Bref, un avis un peu mitigé au final. Bien sûr l’aspect « manuel de référence » a trouvé mieux depuis, je pense surtout au livre d’Angelika Langer. L’étude de cas aurait mérité un traitement plus structuré, probablement en 3 partie, avec une pour chaque environnement système (Windows et OS2) expliquent le fonctionnement des contexte graphique et permettant d’aborder des wrappers. Et une troisième partie pour construire les extensions de la librarie iostream et des exemples de mise en œuvre.

Le livre échoue finalement à bien sélectionner son objectif. Il y en 2 ici et il ne me semblait guère possible de bien les traitre tous les deux en 300 pages.

Référence complète : Object oriented I/O using C++ iostreams – Cameron Hughes – Thomas Hamilton & Tracey Hughes – John Wiley & sons 1995 – ISBN: 0-471-11809-5

http://www.goodreads.com/book/add_to_books_widget_frame/0471118095?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on