Note : 7 ; Un excellent ouvrage regroupant règles, conseils et nombre d’idiomes.

On n’a pas l’habitude de chercher des livres allant au-delà du niveau initiatique chez les auteurs français. A juste titre, malheureusement. Celui-ci fait exception. Cet ouvrage à taille humaine (environ 300 pages), regroupe un ensemble de conseils et de règles en C++, intégrant des idiomes parfois créés par l’auteur. La bête se présente sous forme de 9 chapitres, donc en moyenne un peu plus conséquents que ce que j’escompte. J’oublie les 10 pages d’annexes.

Le premier chapitre parle de rappels. On y trouve pèle mêle des questions sur le partage d’objets pointés, d’ownership, de questions afférents à la destruction, à la notation ou au constructeur de conversion. Ca manque un peu de logique. On ne peut qu’espérer que le meilleur soit à venir.

Au chapitre 2, on trouve des conseils assez sibyllins sur la conception d’une classe. L’auteur ne développe pas les points, mais beaucoup sont pertinents au-delà du bon « bon sens intuitif » : pas d’attributs de type référence ou mettre à disposition la copie d’objet si aucun attribut ne stigmatise son identité (tout le monde ne sera pas d’accord là-dessus, mais je le suis).

Le chapitre 3 est nettement plus important : il adresse les « patterns de programmation », donc en fait les idiomes et taille 70 pages ! Ce chapitre, c’est un peu la trousse à outil de l’auteur avec son savoir-faire. Et ce savoir-faire est de bon niveau ! Il faudra ne pas être totalement néophyte toutefois pour en faire usage. D’abord parce que les explications, si elles tentent d’être didactiques sont plus empreintes du style IBM que du style Scott Meyers, disons… Ensuite, il faut garder un regard critique. Par exemple l’idiome sur le constructeur copie est erroné…

Au chapitre 4, on trouve quelques principes de codage orientés compilation qui ne sont pas sans rappeler le « large scale C++ design » de Lakos. J’aime bien le tableau sur l’usage des références, entre autre chose.

Le chapitre 5 nous parle de debug. On commence par les traces et l’auteur nous donne quelques conseils sur la surcharge de l’opérateur « >> ». Puis on aborde les choses sérieuses avec la surcharge de new pour traquer la mémoire. Là aussi la prudence s’impose car le programme peut ne plus se comporter à l’identique avec et sans debug (vous me direz que c’est déjà le cas…).

Les chapitre 6 et 7, c’est un peu le col du Galibier de ce livre. Du moins, le 7 est la première côte de l’ascension. L’auteur y énumère des règles de code « prêt à l’emploi » qui sont détaillées au chapitre au chapitre 8. Ce sont dans les 80 pages de ce chapitre que Philippe Prados déploie son expertise, et c’est ce chapitre qui justifie l’achat du livre. Si vous ne devez lire qu’un chapitre c’est celui-ci. J’approuve la plupart des règles, j’ai même parfois appris quelque chose (eh oui !) et les explications sont claires pour peu que vous ne soyez pas grand débutant.

Le chapitre 8 consacré aux tests accuse son âge. Il se focalise d’abord sur les notions de préconditions / postconditions et invariants tels qu’on les trouvent dans Eiffel. Puis l’auteur nous propose une implémentation de tests unitaires, qui n’a plus guère d’intérêt aujourd’hui avec des libraires telles que CppUnit.

Au chapitre 9, on démystifie certains mécanismes du C++. Bonne idée ! Au programme : les héritages simples, multiples et virtuels. Tout naturellement on voit dans la foulée le mécanisme des table vptr des méthodes virtuelles. La gestion des exceptions et des inlines complètent le tableau.

Les explications sont assez claires et l’auteur parvient tout à fait à faire passer son expertise (de niveau élevée) du langage. Les recommandations énoncées ont souvent un caractère subjectif, on y adhèrera ou pas mais même dans ce dernier cas on profite des raisonnements et de l’expertise de l’auteur. Disons le tout net, c’est le seul ouvrage d’un auteur Français sur le C++ qui soit d’un niveau honorable ! Un excellent livre, à classer dans la catégorie “manuels de référence”.

Référence complète : La qualité en C++ – Philippe Prados – Eyrolles 1996 – ISBN : 2-212-08917-1

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

Note : 7 ; Des conseils d’expert sur l’utilisation avancée du C++, pour le développeur émérite. N’est toutefois pas à la hauteur des ouvrages de Scott Meyers.

Ce livre fait également partie de la série à laquelle appartiennent les ouvrages de Tom Cargill et Scott Meyers. Il s’agissait à l’époque de produire une série d’ouvrage donnant des avis d’experts. Si « effective C++ » donna non seulement naissance à une série de texte mais aussi inspira d’autres auteurs, celui-ci reste plus qu’honorable. Ecrit par le créateur de C++ Report et chroniqueur de “C++ obfuscated” dans cette même revue, ce livre s’attaque à des préoccupations très techniques : effet de bord des initialisations, de l’héritage virtuel, etc… Chaque chapitre se termine par un paragraphe “En bref” qui résume celui-ci, et par un paragraphe “Questions” qui permet au lecteur de faire le point sur ses connaissances acquises.

C’est la traduction Française que j’ai acquise. Dans cette version, le livre compte quand même 280 pages réparties en 11 chapitres.

Plus que de langage, c’est de conception dont nous parle le chapitre 1 et plus particulièrement d’abstraction (et aussi d’héritage, donc). Mais point de code C++ ou à peine, mais un bref aperçu des cartes CRC.

Long de plus de 40 pages, le chapitre 2 évoque les classes et de nombreux aspects de conception et de comportements qui tournent autour : constructeurs par défaut ou de copie (et donc forcément opérateur d’affectation), on y traite précisément la différence entre initialisation et affectation. Bien d’autres subtilités (constance, membres de type référence, etc…) sont couvertes. Je trouve un peu dommage que l’auteur, s’il présente avec brio le comportement du langage ne prenne pas plus position.

Le titre du chapitre 3 est un peu abscons car il parle de « descripteurs », en fait il s’agit de stratégies de pointeurs intelligents tels que le « copy on write » ou le comptage de références. L’utilité pratique de ces techniques a baissé avec le temps, du fait de la baisse des coûts d’allocation, de l’augmentation des tailles mémoire, mais surtout de l’avènement du multi-threading et des architectures multi-cœurs. Mais la compréhension de ces mécanismes reste un excellent exercice, lui-même excellemment expliqué.

Le chapitre 4 traite en profondeur le cas de l’héritage simple, qu’il soit public, privé… ou protégé. C’est l’un des rares ouvrages de ma connaissance traitant de ce dernier cas il est vrai pas très utile. L’auteur n’oublie pas de parler des méthodes virtuelles et virtuelles pure et explique précisément le fonctionnement des constructeurs et destructeurs dans ces situations. Rien à redire.

C’est à l’héritage virtuel qu’est consacré le chapitre 5 et seulement à cela. Bob Murray utilise abondamment les diagrammes de Venn pour expliquer les principes sous-jacents. Bien sûr on n’échappe pas à l’héritage en diamant et à son corolaire : l’héritage virtuel. Si le cas de classes de bases héritées différemment (public, protégé, privé) est mentionné, l’auteur ne rentre pas dedans plus avant, par contre il évoque la dominance d’héritage ce qui est rare. Ici aussi, l’auteur excelle à expliquer les choses en détail, mais moins à prendre position.

C’est toujours d’héritage dont il est question au chapitre 6. Ici l’auteur rentre dans des questions de conception : quand et comment concevoir pour l’héritage ? L’héritage peut-il induire des comportements erronés ? Et plus précisément comment se comportent constructeurs et destructeurs. J’ai été surpris de ne pas voir évoqué l’héritage privé dans le cas de classes fournissant des services non virtuels aux classes dérivées, et de ne pas voir trace de l’usage du « template method ».

Le chapitre 7 est le premier à évoquer les templates. On reste en zone de sécurité avec la démonstration de template sur des smart pointeurs ou sur des fonctions. Les exemples de code deviennent aussi non triviaux. A l’époque où le texte fut écrit, le comportement des templates était peu spécifié, on n’est donc pas étonné de ne pas voir l’auteur y entrer en profondeur. L’impact sur l’instanciation de code est toutefois débattue.

C’est encore de templates dont parle le chapitre 8. Faisant suite au chapitre précédent, celui-ci est entièrement dévolu aux problématiques d’implémentation de conteneurs avec des éléments homogènes ou non et aux sémantiques de conteneurs par valeur ou par référence. Une lecture franchement difficile à suivre.

On passe aux questions de réutilisabilité au chapitre 9. Ici on se situe plus au niveau des pratiques permettant la réutilisation au niveau d’une classe : celle-ci est-elle bien documentée, avec de bons nommages ? Qu’en est-il de sa robustesse, celle-ci est-elle éprouvée avec des assertions (on ne parlait pas de tests unitaires à cette époque) ? Une grande partie du chapitre est dédiée aux questions de débogage et comment rendre son code monitorable dans ces conditions. La partie consacrée aux allocateurs et à la façon de les rendre parlant est particulièrement intéressante, y compris aujourd’hui.

On ne pouvait échapper à un chapitre consacré aux exceptions. C’est le chapitre 10. La prose n’est pas exceptionnelle, si je puis dire, même si c’est la première fois qu’on y évoque le « les exceptions doivent être exceptionnelles ».

Le livre se termine avec un chapitre sur la migration d’applications vers C++. Il s’agit en fait de considérations et d’un ensemble de conseils (de bons conseils) pour ceux passant du C au C++.

Cette ouvrage est d’une lecture aisée, du moins pour le développeur déjà expérimenté en C++, et se consomme rapidement en une semaine ou deux, ce qui n’est pas la moindre de ses qualités. La petite surprise est que le texte ne se focalise pas uniquement sur le langage mais aussi sur son usage et sur une bonne compréhension de la conception : qu’est-ce qu’une bonne classe, une bonne abstraction, etc… Le texte mériterait un bon rafraichissement car il accuse maintenant 2 décennies, mais il reste de très bonne tenue.

Référence complète : Stratégies & tactiques C++ – Robert B. Murray – Addison Wesley 1994 (V.O. : C++, Strategies & Tactics ; Addison Wesley 1993 ; ISBN : 9780201563825) – ISBN : 2-87908-066-5

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

Note : 3 ; Difficile d’accès et même embrouillé, mais une des rares sources d’informations sur le sujet.

Ce très coûteux petit bouquin constitue probablement l’un des seuls (sinon le seul) manuel de référence sur les iostreams, du moins sur les “pré-standard” streams. Personnellement, hors son impression et sa mise en page de qualité très moyenne, je trouve les explications assez succinctes et parfois ambiguës. C’est néanmoins (et de loin) le bouquin de C++ que l’on m’a le plus souvent emprunté. Donc…

Malgrès son aspect sommaire, cet opuscule compte tout de même 355 pages annexes comprises et est structuré en 21 chapitres.

Tout comme « Object Oriented I/O using iostreams » ce livre concerne l’ancienne librairie iostreams. Certains détails ne sont plus d’actualité. Pour la nouvelle librairie IOStreams, vous pourrez vous reporter à l’ouvrage d’Angelika Langer: les utilisateurs du standard ont bien de la chance, car ce dernier ouvrage est, lui, quasi-irréprochable ! Son approche se veut celle d’un tutorial, alors que je l’ai surtout plus ou moins utilisé comme un manuel de référence (à défaut d’autre chose…). Mais même comme tutorial, il ne brille pas par son approche pédagogique. Les textes explicatifs sont très sybillins et franchement incomplets, tout comme les fragments de code. Ce sont pourtant eux qui m’ont servi, ou plus exactement servi de point de départ dans mon utilisation des iostreams ! Mais quelle prose embrouillée, quelle énergie dépensée (et avec quels nervements !) pour arriver à sortir quelque chose de ce texte.

Ce fut vraiment une grande source de frustration de n’avoir eu que ce livre pour m’aider un tant soit peu à utiliser la librairie iostreams pré-standard durant tant d’années. Le livre n’est plus commercialisé, c’est fort logique et c’est tant mieux !

Référence complète : C++ iostream handbook – Steve Teale – Addison Wesley 1993 – ISBN: 0-201-59641-5

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