Note de lecture : Programmation avancée en C++ styles et idiomes, par James Coplien

Note : 7 ; Un ouvrage remarquable, historiquement le premier sur les idiomes.

Cet ouvrage figure parmi les titres de référence du C++. Il fut le premier à mettre en évidence les possibilités offertes par le langage afin de construire des idiomes. La plupart de ceux-ci sont maintenant institués en standards de fait du C++, tel « handle-body ». Le style est par ailleurs agréable, mais ainsi que le titre le suggère, ce n’est pas un « premier livre » pour aborder le C++. Ce n’est pas non plus une lecture de dilettante : le texte compte 360 pages structurées en 11 chapitres, auxquelles il convient d’ajouter les 100 pages consacrées aux annexes !

Après une courte introduction, le chapitre 1 s’attaque à ce que j’appellerais les fondamentaux de la POO et du C++ : qu’est-ce qu’une abstraction, que fait-on dans un constructeur et un destructeur, mais aussi des choses légèrement plus avancées comme les fonctions membres statiques ou les pointeurs sur fonction. C’est bien écrit, mais aussi sans concession pour le lecteur : ce n’est pas un livre de plage, le message est clair.

Le chapitre 3 aborde un volet moins connu des objets : les types concrets de données, ce qui permet à l’auteur d’aborder son premier idiome : la forme canonique orthodoxe. Un « must know » de tous les développeurs C++ ! Le chapitre est très riche, car il couvre bien évidemment les surcharges d’opérateurs (y compris new et delete) et présente un second idiome : le pointeur avec comptage de référence.

Le chapitre 4 traite des fondamentaux de l’héritage, c’est à dire de l’héritage simple et public. Il couvre bien les aspects de contrôle d’accès, cinématique des constructeurs et destructeur, etc… Mais dans cet exercice, James Coplien est plutôt moins efficace qu’un Stanley Lippmann, par exemple.

Avec 75 pages, le chapitre 5 est également un gros morceau. Il faut dire que son ambition est de traiter de la programmation objet. Il n’est donc pas étonnant qu’il ait d’avantage une odeur de conception. Il compte d’ailleurs pas moins de 3 idiomes au programme : enveloppe/lettre, constructeur virtuel (une dérivation du précédent, en quelques sortes…) et objet fonction (largement utilisé dans la STL). Plus curieusement, il couvre aussi les aspects avancés de l’héritage : héritage multiple et virtuel et héritages privé et protégé. Cela se raccorde mal au reste et aurait pu figurer dans un chapitre séparé.

Le chapitre 6 se détache un peu du C++ pour parler conception : qu’est-ce qu’une classe ? Comment identifie-t-on ce qui doit être une classe ? Nature des relations entre objet et sémantique de l’héritage. Un gros morceau est la sémantique « est un » détaillé dans le principe de substitution de Liskov. Sans être un tour de force, ce chapitre est fort convenable. On notera l’utilisation de la notation Booch pour les diagrammes.

C’est le serpent de mer de l’objet qui est abordé au chapitre 7 : la réutilisation. Cela en fait un des chapitres les moins utiles du livre. Mais c’est aussi l’occasion d’introduire les templates.

Les templates, justement : parlons-en ! Ils sont l’objet du chapitre 8. On y retrouve la notation Booch et un nouvel idiome : la communauté de templates. Pas l’idiome le plus utile, hélas. Bref, ce court chapitre n’est pas spécialement grandiose.

Le chapitre 9 augmente le niveau de complexité de la lecture, car l’auteur se propose d’émuler les langages dynamiques (curieusement appelés ici « langages symboliques »). On y trouve un idiome, le « multi-méthodes » et des considérations d’implémentations concernant le garbage collecting et le chargement incrémentale de code, c’est à dire en fait la liaison tardive du code.

Le chapitre 10 est très court et poursuit sur la même lancée avec l’héritage multiple dynamique. Peu convainquant. En fait, je n’ai même pas compris où l’auteur voulait en venir…

Enfin le chapitre 11 se tourne vers des considérations plus système, comprenez : des considérations de structuration ! On y présente les diagrammes de transaction et on y évoque les modules, la distribution et la parallélisation, même si tous ces sujets ne sont pas excellemment traités.

Ce livre est très ancien. Il a eu le mérite en son temps d’ouvrir les yeux du programmeur en faisant comprendre qu’il existe un autre niveau de compréhension du langage que la simple bonne appréhension de la syntaxe. A ce titre, il a ouvert la voie à bien des ouvrages de C++ avancé ! Il reste la référence pour un certain nombre d’idiomes qui y sont présentés et ce avec une grande rigueur. En fait je pense que le livre aurait dû se focaliser exclusivement là-dessus ! Certains sujets sont abordé en mode plus introductifs. La question se pose de la pertinence de leur évocation ici, mais finalement ça valait probablement le coup. Bref, un très bon livre, très solide et pas « has been » finalement !

Programmation avancée en C++

Référence complète : Programmation avancée en C++, styles et idiomes – James Coplien – Addison Wesley 1992 (V.O. : Advanced C++ Programming Styles and Idioms ; Addison Wesley 1992) – ISBN : 2-87908-014-2

Programmation avancée en C++


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

Publicités

Note de lecture : Object oriented I/O using C++ iostreams, par Cameron Hughes, Thomas Hamilton & Tracey Hughes

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.

Object-Oriented I/O using C++ iostreams

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

Object-Oriented I/O Using C++ Iostreams


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

C++ en 1983…

J’ai posté il y a peu une note de lecture sur l’Annotated Reference Manual (l’ARM pour les intimes). Cela m’a incité à aller chercher plus loin. C’est ainsi que j’ai mis la main sur un document dont on devine à sa seule apparence qu’il est plutôt ancien. Je ne peux résister au plaisir, en passant, de vous livrer la photo de famille du premier meeting du groupe de travail sur C++.

Initial meeting Group C++

Bjarne Stroustrup n’a pas tellement changé, vous allez le reconnaitre facilement !

Voici le document en question.

On ne peut pas vraiment parler de norme, ce document décrit le langage C++ d’une manière que l’on dirait aujourd’hui sommaire. Certains éléments du langage sont absent de cette version préhistorique. Les plus remarquables sont l’absence des mots-clé pour les visibilités private et protected !

Note de lecture : More C++ Gems, Robert C. Martin edt.

Note : 4 ; Compilation hétéroclite

On oublie parfois que Robert Martin a été éditeur en chef de C++ durant plusieurs années ! Les articles regroupés ici sont la seconde fournée des morceaux choisis de plus de 10 ans de C++ Report ! Le premier volume était la sélection de Stanley Lippman, celle-ci vient d’un auteur ayant une sensibilité différente.

Le volume n’est pas anodin : il compte plus de 500 pages divisées en 2 parties inégales : la plus petite « diamonds from deep in the past » est la plus courte tandis que « Present day industrial diamonds » représente la portion congrue. Il y a 24 articles en tout, 6 dans la première partie et 18 dans la seconde.

Tout ne mérite pas le détour dans la première partie. Je passe très vite sur le « finite state machine » qui ne nous apprends pas grand chose, pas plus que l’article traitant des classes abstraites et de fonctions virtuelles pures. L’article de Cay Horstmann sur les smart pointers mérité définitivement plus d’attention car il traite de certains problèmes afférents à leur utilisation. A lire. De même « pointers vs references » c’est un peu du retour aux fondamentaux, mais c’est Stan Lippmann. Il faut toujours lire Stan Lippmann. L’article sur les NULL est rentré par une oreille et sorti par l’autre et la prose de James Coplien sur les patterns oublie d’être passionnante. On termine cette première partie par un article sur les patterns du regrété John Vlissides. Cela a à peine sa place ici, mais c’est tellement agréable à lire…

L’open-close principle qui ouvre la seconde partie du livre (et donc les 400 pages restantes) est bien, mais c’est du réchauffé, non seulement de C++ Report mais des propres livres de Robert Martin ! La prose de John Lakos qui suit est très longue. C’est même le monument de ce livre avec près de 90 pages, mais c’est à lire absolument. Il s’agit d’un condensé de son « large scale C++ design » et l’auteur nous y livre les stratégie de structuration de programmes pour gérer les dépendances, les temps de compilation ou de link. C’est passionnant et excellemment illustré !

Les deux articles qui suivent (taskmaster et monostate class) sont plutôt du domaine des patterns. Ils sont d’un intérêt assez moyen. Par contre celui sur les métriques ABC, sans être grandiose, nous propose une alternative intéressante au LOC. Ce n’est pas le cas du « patterns for mapping OO applications to relational database » qui est très léger et n’aurait pas dû figurer ici.

Heureusement, on arrive en terrain plus sérieux : avec Herb Sutter d’abord : les exception-safe container, c’est du lourd et on en a 30 pages ! L’anatomie de l’opérateur d’affectation, c’est du fondamental mais l’auteur creuse bien le sujet, parfait ! On est plus côté système (avec une pincée de patterns) sur cet article de Doug Schmidt sur les thread local storage. C’est du solide et ça ne se laisse pas lire comme ça. L’article de Matthew Austern sur l’exception safety fait écho à celui de Herb Sutter sur les exception-safe container. Bonne lecture aussi, j’approuve. A propos d’Herb Sutter, deux articles de cet auteur viennent à la suite. C’est du C++ pour les hommes, les vrais : lisez-les !

Je suis un peu désappointé de voir ici « external polymorphism » qui devient réellement un plat réchauffé plusieurs fois… Je passe rapidement sur le « safe deletion » qui a trait au multi-threading (mais pas terrible). Doug Schmidt, encore lui, nous parle de performances avec GPerf. Ce n’est pas de la lecture facile, hélas. L’ouvrage se conclut de nouveau par 2 articles d’Herb Sutter (à lire donc). Le second est un peu frustrant car il ne fait que 3 pages pour nous mettre l’eau à la bouche avec le langage BOOSE, une extension à C++. Mais hélas on n’en sait pas beaucoup à la conclusion de l’article !

Cette compilation manque un peu de cohérence. Il aurait fallu, à mon avis séparer les parties « pur C++ », la partie « patterns » et la partie « système ». Cela aurait déjà été plus clair. Le titre même de l’ouvrage est trompeur eut égard à la place importante consacrée aux patterns. Il aurait dû s’intituler : C++ and Patterns in C++ Gems. Bref, un problème de cohérence pour cette compilation qui se reflète dans la note. Comme je l’ai noté, il y a de bons articles, notamment ceux d’Herb Sutter, mais cet auteur a aussi ses propres ouvrages.

Bref, un ouvrage pas vraiment indispensable.

More C++ Gems

Référence complète : More C++ Gems – Robert C. Martin – SIGS books / Cambridge University press 2000 – ISBN: 0-521-78618-5

More C++ Gems

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

Note de lecture : The Annotated C++ Reference Manual, par Margaret A. Ellis & Bjarne Stroustrup

Note : 6 ; Extrêmement austère, mais indispensable pour connaître le détail de comportement du langage … avant la norme !

 L’ARM est un ouvrage qui fait plus que dater (il a été écrit en 1991), et il aurait dû être relayé par un ouvrage équivalent traitant du langage tel qu’il a été standardisé. Des documents de standardisation du langage ont bien été publiés (pour le C++ 98 et le C++ 11), mais ce livre reste LE livre de référence sur le langage tel qu’il fut définit au départ. Il s’utilise comme tel, par conséquent sa lecture linéaire est extrêmement difficile, voire inutile. Il a servi de document de départ au comité de normalisation ANSI, et bien que certaines assertions soient désormais invalides, Il s’agit bien là de la description (sèche) la plus exhaustive du langage actuellement éditée. Ce livre ne peut aider que les développeurs très aguerris dans le langage, ayant besoins de lever des ambiguïtés à des fins de portabilité du code, de génération de code, etc..

Ouvrons un peu la bête pour voir ce qu’elle a dans le ventre. Malgré un volume apparemment modeste, le texte compte 440 pages sur 19 chapitres et aucune annexe. En fait, le livre lui-même pourrait être considéré comme une grosse annexe !

Je passe le chapitre 1 d’introduction qui replace le C++ dans son contexte historique. Le chapitre 2 évoque succinctement des éléments de syntaxe : les mots-clés, ce qu’est une constante littérale, etc..

Les choses sérieuses commencent au chapitre 3 où l’on traite des bases, à savoir des déclarations et des portées de celles-ci. En conséquence, on évoque bien entendu les déclarations static et extern et la façon dont elles sont appréhendées par le linker. Et on traite aussi de classes de stockage. Les types de base et leurs dérivés sont aussi évoqués.

Le chapitre 4 est très court et exclusivement dévolu aux conversions, qu’elles soient numériques ou qu’elles portent sur des pointeurs ou des références. On a droit à un des rares diagrammes du livre.

En comparaison, les 35 pages du chapitres 5 consacré aux expressions (et donc aux règles d’évaluation) en font une partie très dense de l’ouvrage. Il faut pas mal de concentration pour suivre le propos, mais ces règles restent valables aujourd’hui et sont un fondement de la façon dont le langage fonctionne !

Les « statements » évoqués au chapitre 6 concernent les instructions de débranchement (if, switch) et les instructions de boucles (for, while, do). C’est reposant et on apprends 2 ou 3 trucs au passage, comme les règles de résolution d’ambiguïté !

Le chapitre 7 revient sur les déclarations, mais plus précisément sur les spécifiers ! C’est l’occasion d’en apprendre plus sur les inline, friend, typedef et autres volatile (la bête noire des langages). Les annotations qui suivent donnent quelques lumières sur extern « C » et sur les fameux « name mangling » qui m’ont causé tant de tracas par le passé !

Le chapitre 8 sur les déclarations n’est pas d’un abord trop compliqué. Il traite aussi bien des déclarations de variables et de fonctions (et de classes), que ce soit par valeur, par pointeur ou par référence. Pas grand chose à en dire.

Le chapitre 9 était très attendu : il traite des classes ! Même si le sujet se poursuit au chapitre suivant, celui-ci fournit une bonne couverture du sujet, qui ne se limite pas aux déclarations mais couvre aussi (par exemple), la gestion du pointeur this, les déclarations friend ou les classes imbriquées. Les classes dérivées sont traitées au chapitre 9 et on rentre à fond dans le sujet, avec des héritages simples, multiples en branches ou en diamant et même circulaires ! Le chapitre 11 qui clos le sujet est une petite balade de santé traitant des fameux public, protected et private mais aussi de l’inénarrable « friend » !

Le chapitre 12 nous parle des fonctions membres spéciales. Elles forment des aspects alambiqués du langage mais leur connaissance est précieuse : destructeur, constructeur (par défaut, à un argument ou de copie), opérateurs de conversion et opérateurs d’allocation / désallocation. Un propos très complexe à suivre mais combien important !

La surcharge n’est pas mon mécanisme préféré, bien qu’il rende des services. Les 30 pages de ce chapitres 13 vous feront comprendre combien ce mécanisme n’est pas trivial, quand il s’agit de comprendre « l’argument matching ».

C’est une surprise de ne voir que 10 pages à peine consacrées aux templates dans ce chapitre 14, tant les déclinaisons de ce mécanisme s’avèrent complexes. Mais à cette époque, on en est qu’aux balbutiements du sujet. De nombreuses sources plus récentes donneront des informations plus complètes et à jour.

Les exceptions, traitées au chapitre 15 sont aussi un sujet « récent ». Il est plus simple et traité ici sur 13 pages, donc finalement plus décemment. Mais ce n’est pas encore formidable. Là aussi on trouvera sans peine de meilleures sources.

C’est une surprise de voir ici ce chapitre 16 consacré… au préprocesseur ! Il est vrai que ce vieux mécanisme du C perdure au C++ (on ne peut hélas l’éviter pour un certain nombre de choses…). Le point d’orgue de ce chapitre, c’est quand Bjarne Stroustrup nous montre l’apparence d’une chaine ANSI sur un terminal… Danois !

Le chapitre 17 sent la fin de l’ouvrage : il s’agit d’un résumé de la grammaire sous la forme d’une BNF. En fait celle-ci est incomplète : la seule partie concernant les expressions devrait à elle seule noircir une bonne dizaine de pages… Le chapitre 18 couvre quelques pages à évoquer la compatibilité entre le C++ et le C, mais aussi avec la version de C++ de 1985 !

La quinzaine de pages du chapitre 19 évoque les futures résolutions ANSI/ISO. On y trouve pêle-mêle la gestion des namespaces (et bien sûr la clause using) et aussi les nouveaux types de casts. Je dois certainement en oublier…

La lecture de ce livre est disons… challengeante ! Le style est tout sauf abordable, mais certains points de détail y sont abordés avec grande précision et restent valables aujourd’hui. Toutefois, l’utilité de ce livre est moins criante désormais, voire sans objet, car le document normatif peut le remplacer. Ce dernier est plus à jour et aussi plus complet et détaillé. Cet ouvrage n’a donc plus qu’un intérêt historique.

The Annotated C++ Reference Manual

Référence complète : The Annotated C++ Reference Manual – Margaret A. Ellis & Bjarne Stroustrup – Addison Wesley 1991 – ISBN: 0-201-51459-1

The Annotated C++ Reference Manual


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

Note de lecture : La qualité en C++, par Philippe Prados

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”.

La Qualité en C++, par Philippe Prados

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

La qualité en C++


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 de lecture : The C++ Programming Language 3rd edition, par Bjarne Stroustrup

Note : 4 ; En net progrès depuis la 2nd édition, mais encore fort confus.

Bien que très abondamment vendue, la seconde édition de cet ouvrage de référence ne pouvait se vanter d’être un livre incontournable. Le propos de l’auteur étant à la limite de la confusion, et les références multidirectionnelles (aussi bien vers l’avant que vers l’arrière) incessantes ainsi que les exemples incomplets en faisaient un ouvrage pratiquement inabordable pour les nouveaux venus au langage. Bref, il était loin d’offrir un pendant au célèbre ouvrage de Kernighan et Ritchie. Cette nouvelle mouture (qui ne l’et plus désormaisn, car il existe une 4ème édition) s’est grandement améliorée, même si elle est loin de faire taire les critiques énoncées ci avant : le propos de l’auteur est devenu plus clair, l’ouvrage s’est étoffé, et pas qu’un peu avec ses 900 pages, et il traite du C++ standard (avec toutes les nouveautés) y compris la librairie standard. En venir à bout relève du marathon, fort heureusement l’auteur a pensé aux étapes : le livre se découpe en 25 chapitres regroupés en 4 parties.

Avant même la première partie, 3 chapitres d’introduction dont un « tour du C++ » et un « tour des librairies » donnent (ou devraient donner) un bon aperçu du langage. Las, on passe très vite de sujet en sujet sans forcément comprendre comment on en est arrivé là : des templates aux containers en passant par les Stream, on a effectivement un aperçu, mais en accéléré ! On rembobine pour se remettre sur la ligne de départ !

La première partie « basic facilities » couvre 6 chapitres sur 150. Au programme : types et déclarations (chapitre 4), pointeurs, tableaux et structures (chapitre 5), expressions (chapitre 6), fonctions (chapitre 7), exceptions et namespaces (chapitre 8) et fichiers sources et programmes (chapitre 9). Déjà ça va mieux, la progression est moins décousue. La plupart des exemples de code sont assez courts et ils sont aussi très nombreux. Ils comptent pour environ la moitié du texte. Nonobstant, l’auteur ne peut s’empêcher d’utiliser des « petits trucs rigolos » dans ses exemples de code, qui ne font rire que lui : utilisation des iostreams, des références sur … eh bien on ne comprend pas trop quoi, des nommages façon vieil Unix sur une ou deux lettres qui rendent les exemples de code très hermétiques.

C’est aussi 6 chapitres pour la seconde partie « abstraction mechanisms », mais avec un tarif de 225 pages, cette fois. On a à l’affiche : classes (chapitre 10), surcharge d’opérateur (chapitre 11), classes dérivées (chapitre 12), templates (chapitre 13), gestion d’exception (chapitre 14) et hiérarchies de classes (chapitre 15). Ca recommence presqu’humainement au chapitre 10, n’était-ce l’incurable habitude du créateur du C++ de rentrer tout de suite dans les arcanes complexes du langage. Bien sûr le chapitre sur la surcharge d’opérateurs n’arrange rien, on côtoie rapidement le cas des opérateurs globaux friends, par exemple. L’héritage couvre non seulement les cas simples, mais aussi les classes abstraites (donc les méthodes virtuelles pures) et bien entendu l’héritage multiple. Les exemples me donnent surtout l’impression d’arriver à rendre ardu un sujet que je maitrise maintenant très bien. Tout cela me laisse craindre le pire quand au chapitre sur les templates. Mais si celui-ci ne fait pas de cadeau, il s’arrête à un niveau de complexité appréhendable par le commun des mortels. Les deux derniers chapitres de cette première partie sont une heureuse surprise. En fait, l’explication sur les hiérarchies de classes où l’on voit aussi l’héritage en diamant et l’héritage virtuel est même un exemple de pédagogie !

La 3ème partie aborde enfin la librairie standard : on en prends pour 7 chapitres et 260 pages. Des chapitres 16 à 19, on traite de la STL, puis viennent les String (chapitre 20), les Stream (chapitre 21) et les Numeric (chapitre 22). La STL est une librairie complexe et on ne peut reprocher à Bjarne Stroustrup de faire des impasses, mais s’y retrouver ici relève de la gageure. Heureusement j’ai en réserve d’autres références qui font mieux à cet égard ! Le chapitre sur les String nous permet de souffler… et même de comprendre ce que sont les traits ! Mais les Stream, sujet déjà difficile en soit nous assure la noyade. Avec les Numeric, c’est à peine mieux.

La dernière partie est dévolue à des considérations de conception. Elle se contente de 3 chapitres et 110 pages. Le chapitre 23 n’a même pas de code, et les deux suivant moins qu’il n’est de coutume. C’est le moment pour le père du C++ de dispenser un cours de programmation et de conception. Ce n’est pas sans intérêt, mais le Dr Stoustrup reste un pédagogue assez moyen…

Le grand mérite de cet ouvrage est d’avoir été le premier à paraître et à faire figurer ces éléments “up to date”. Depuis, est sorti la 3ème édition du “C++ primer” de Stan Lippmann (épaulé cette fois par Josée Lajoie), encore plus volumineux, et qui dépasse, sans coup férir, le livre de Bjarne Stroustrup par sa qualité. Bien sûr le « C++ 11 » est aussi arrivé depuis. L’occasion de publier 15 ans après une 4ème édition qui pèse le monumental volume de 1400 pages !

Difficile de recommander ce texte : il est difficile d’abord. Il nécessite souvent de relire 2 ou 3 fois un passage pour le comprendre. L’auteur n’a guère pitié de nous car les exemples, s’ils sont courts et nombreux surabondent en éléments connexes qui ne sont généralement pas connus et compliquent la compréhension. Il reste aussi un fervent de ce que j’appelle les « références en avant ». On ne pourra pas reprocher à l’auteur de faire l’impasse sur quoi que ce soit, mais que c’est dense. Chaque chapitre se termine par des conseils et des exercices. J’avoue ne pas avoir eu le courage de les faire. Par contre, les citations au début de chacun d’entre eux sont particulièrement pertinentes et savoureuses. Bref, une bonne lecture pour masochiste.

c++-prog-lang-stroustrup

Référence complète : The C++ Programming Language (3rd edition) – Bjarne Stroustrup – Addison Wesley 1997 – ISBN: 9780201700732

The C++ Programming Language


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

Note de lecture : Stratégies & tactiques C++, par Robert B. Murray

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.

cpp-strategies-tactics

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

C++ Strategies and Tactics

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 de lecture : Ruminations on C++, par Andrew Koenig & Barbara Moo

Note : 6 ; Amis touristes, ce livre n’est pas pour vous !

Au premier abord, l’ouvrage n’en impose pas trop, le volume semble modeste sans parler du design de la couverture façon vache qui rit. Mais rapidement, on se rend compte déjà que la finesse du papier nous avait dissimulé ses 370 pages.

Ce livre qui est plutôt un recueil, est un compilation des articles d’Andrew parus essentiellement dans JOOP (Journal of Object-Oriented Programming), mais aussi dans C++ Report et dans C++ Journal pour une petite partie d’entre eux. C’est donc dans une sélection de 98 articles publiés sur une durée de 8 ans que les auteurs ont fait leur choix. Ils sont regroupés sur 32 chapitres, pardon 33 car Andrew Koenig, en bon informaticien commence par un chapitre 0 ! Ces chapitres sont eux-mêmes rassemblés en 6 parties.

La première partie « motivations » présente assez peu de code. L’auteur y développe son crédo personnel envers C++, essentiellement en le comparant au langage C auquel il donne clarté et sécurité. Le style y est aussi plus personnel que dans les parties suivantes.

La seconde partie « classes and inheritance » est le prétexte pour revisiter les grands thèmes du C++ classique : héritage, polymorphisme et surcharge, constructeur copie, virtualité, etc… Nous avons même droit à une petite variation sur le thème du smart pointer. Il s’agit plus de l’usage du paradigme objet du C++ que d’un cours sur l’orienté objet.

La troisième partie est consacrée aux templates. En fait, il est consacré à la compréhension de la STL. Cela commence doucement par les conteneurs, puis par les itérateurs, les algorithmes et fonctions pour finalement aborder les adaptateurs. Ce n’est pas à proprement parler un tutorial STL, mais plutôt un apprentissage par la construction de ses mécanismes fondamentaux.

La quatrième partie se focalise sur les principes de conception des librairies. Honnêtement, j’ai trouvé cette partie difficile à aborder, les points fondamentaux des auteurs m’ont paru confus, ainsi que le message d’ensemble.

Si elle est courte, la cinquième partie n’est pas la moins intéressante. Intitulée « techniques » c’est en fait une boite à outil à utiliser pour débugger, tracer, gérer des clusters d’objets, etc…

La sixième partie « wrap up » conclut l’ouvrage. Elle est très courte, il y a peu à en dire.

Ce livre à recommander aux personnes fortement motivées pour approfondir leurs connaissances sur le C++. Même s’il prétend le contraire, la prose d’Andrew Koenig n’est pas du Scott Meyers. Le style est plutôt sec, parfois même un peu confus. Mais le niveau de technicité est au rendez-vous, bien qu’il faille quand même un bagage minimum assez conséquent en C++ pour tenir la distance… Le texte a été remanié afin de ne pas donner une impression trop forte de juxtaposition d’articles. C’est gagné de ce côté, même si tout n’est pas lisse. Les parties plus anciennes ont été remises au goût du jour, c’est à dire celui du pré standard 98, même si les auteurs ne cherchent pas à tout prix à dégainer les dernières nouveautés du langage. Il préfèrent se concentrer sur le « core langage ».

Quel que soit votre niveau, il serait surprenant que vous n’en retiriez pas quelque chose. A une exception près : je déconseille fortement aux débutants !

ruminations-c++

Référence complète: Ruminations on C++ – Andrew Koenig & Barbara Moo – Addison Wesley 1997 – ISBN: 0-201-42339-1

Ruminations on C++: A Decade of Programming Insight and Experience


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