Note de lecture : Serial Communications, A C++ Developer’s guide, par Mark Nelson

Note : 7 ; Bien que désormais obsolète (car concerne surtout Windows 16 bits), reste intéressant sur les principes de gestion des ports série.

Tant que je suis dans les antiquités…en voici une tout à fait honorable ! Certes ce livre a perdu une grande partie de son intérêt, d’abord avec l’arrivée du Windows 32 bit et de TAPI puis des infrastructures et librairies qui rendent aujourd’hui transparente les vicissitudes des protocoles de communication.

Cet ouvrage nous permet, aujourd’hui encore, de nous ressourcer sur la mise en œuvre des communications à bas niveau, là où les caractéristiques du matériel ne peuvent être ignorées ! Mais la bête est imposante : ce sont 600 pages qui se présentent à nous sur ce seul sujet, le tout en 11 chapitres ! Le premier d’entre-eux rappellera des souvenirs aux plus anciens d’entre nous, il aborde l’interface RS 232 C sur 64 pages. Tout y passe, depuis la norme du connecteur, la signification des signaux et les protocoles de transmission modem. L’électronique sous-jacente, les fameux UART sont évoqués, mais leur gestion fera l’objet d’un chapitre à part. Finalement les protocoles d’échange de fichier (Kermit, ZModem, etc.) clôturent le chapitre. C’était en quelque sorte le tour du propriétaire.

Le chapitre 2 s’articule autour de la définition de la classe C++ RS232 ; il s’agit d’un wrapper abstrait sur lequel peu de méthodes concrètes « intelligentes » sont implémentées. Essentiellement les fonctions de lecture et écriture. C’est un bel exemple de mise sous forme de classe d’un protocole, car tous les signaux de la norme apparaissent sous forme de méthodes virtuelles. A part cela le chapitre est peu passionnant, essentiellement constitué de listings.

Ce sont près d’une centaine de pages qui sont dédiées au chapitre 3, dévolu à l’implémentation de RS232C sur l’UART 8250. Toute la première partie expliquant le fonctionnement de l’UART est réellement très intéressante même si je regrette le peu qui est consacré au 16550, certes nettement moins rependu à l’époque, mais nettement plus intéressant. Hélas la seconde moitié du chapitre est de nouveau consacré à de fastidieux listings bien peu expliqués…

Le chapitre 4, shared interrupt device rompt la monotonie avec seulement 25 pages. Il est consacré à l’accès aux ports COM dans l’architecture PC via les 2 interruptions qui leurs sont dédiées (pour 4 ports en principe accessibles). Le code du handler et les principes de gestion sont clairement appréhendés. Des informations par ailleurs rares dans la littérature, pour ne pas dire plus.

C’est à un périphérique plus exotique qu’est consacré le chapitre 5 : le Digiboard ! C’est donc une nouvelle sous-classe de RS232 qui nous attend. Un chapitre dont je soupçonne qu’il tenait à cœur à l’auteur, mais qui n’a pas retenu mon attention.

Plus intéressant pour moi, mais hélas plus légèrement traité, le chapitre 6 nous propose une nouvelle sous-classe de RS232, mais cette fois en s’appuyant sur les primitives disponibles dans le BIOS. Seul 30 pages y sont consacrées et l’auteur aurait pu faire plus d’effort pour développer plus clairement les interruptions du BIOS et leur exploitation.

Au chapitre 7, le FOSSIL driver se voit lui aussi consacrer une trentaine de pages. La profondeur de traitement est à peu près la même que pour l’implémentation BIOS. Mais j’avoue encore une fois que l’aspect exotique de cette norme fait que le chapitre n’a pas retenu mon attention.

Nouvelle alternative au chapitre 8 : une implémentation sur les API Windows. Près de 50 pages sont noircies sur le sujet. Cela paraît mieux, mais à l’époque où ces informations étaient vitales pour moi, la profondeur des informations restait bien insuffisante. Mais au moins le livre fournit des informations d’exploitations de ces APIs, choses pratiquement indisponibles par ailleurs en 1993 !

Le chapitre 9 est long de 40 pages. C’est un changement, car on quitte la couche RS232 pour s’attaquer à la gestion des modems, avec les fameuses normes V24, V32 et autres et bien sûr le protocole Hayes. La question est bien traitée et fort clairement. C’est probablement la meilleure source d’information que j’ai pu croiser sur la question.

Au chapitre 10, on s’attaque aux transferts de fichier, avec les protocoles XModem, YModem et ZModem. La question ne m’intéresse guère et j’ai du mal à avoir un avis sur le chapitre. Le sujet semble bien traité et le listing de fichier une fois encore un peu longuet.

Le dernier chapitre du volume va s’intéresser à l’émulation de terminal. Le thème remplit 60 pages et ne semble guère passionnant tel qu’il est traité ici. On est beaucoup dans l’explication de texte du listing, fort peu sur la déconstruction du problème.

L’auteur a développé une petite librairie de classes multiplateformes, multi-modems et multi contrôleurs qui, ma foi, m’a bien fait de l’usage à son époque. Le livre gravite entièrement autour de cela ce qui rend parfois le propos un peu rébarbatif et les listings ennuyeux. Mais le volet technique est très affuté et ce fut très clairement la meilleure source d’information sur bon nombre de sujets qui y sont traités. Difficile de faire valoir une pertinence après presque 25 ans, pourtant le volume mérite d’être conservé à titre d’archive !

image

Référence complète : Serial Communications : A C++ Developer’s guide – Mark Nelson – Prentice Hall / M&T Books 1992 – ISBN : 0-13-011776-1

Serial Communications: A C ++ Developer's Guide : A Comprehensive Guide to Writing Serial Communications Applications Using Object-Oriented Techniqu

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

Note de lecture : Cross-Platform GUI Programming with wxWidgets, par Julian Smart et Kevin Hock avec Stefan Csomor

Note : 4 ; Pas un truc qu’on lit pour le fun !

Les frameworks IHM en C++ ne sont pas mort ! Et ce volume de 540 pages (hors annexes) compte bien nous en faire la preuve avec wxWidgets. Le bestiaux compte 20 chapitres, il faudrait aussi y ajouter presque 100 pages d’annexes.

Les deux premiers chapitres (assez courts) sont là d’une pour nous présenter très brièvement l’historique de wxWidgets, puis un « hello world » qui nous montre déjà une certaine ressemblance avec MFC…

Dès le chapitre 3 on rentre dans le dur avec la gestion des évènements. Je trouve la prose et les explications assez sèches. D’un autre côté, la petite taille des chapitres aide…

En comparaison, le chapitre 4 « Windows basics » fait plutôt mouse costaud avec ses presque 100 pages ! La prose me semble assez décousue et si la présence de nombreux tableaux de référence semble rassurante, elle fait ressembler ce chapitre d’avantage à un manuel de référence qu’à un tutorial.

La partie sur l’écriture sur les devices ressemble plutôt à une introduction sur le sujet. Fort heureusement on a quitté le mode « manuel de référence ». Si les contextes graphiques, arrières plans, etc… semblent décemment traités, j’ai quelques soupçons sur l’affichage de bitmaps, la gestion des imprimantes me paraît un peu légère et la partie 3D est carrément un gag !

Passons sur le chapitres 6 dédié à la gestion des inputs pour arriver aux chapitres 7 et 8 consacrés aux layouts puis aux dialogues standards. Ces deux chapitres sont justes introductifs avec de petits fragments de code pour illustrer les cas courants. En gros, ce que propose le manuel en ligne de wxWidgets. Ce n’est pas le cas du chapitre 9 qui traite les « custom dialogs » et s’appuiera sur un exemple plus conséquent.

Si le traitement des images au chapitre 5 m’avait déçu, le chapitre 10 rattrape le coup en traitant exclusivement de cet aspect.

Le drag and drop est toujours une fonctionnalité complexe, difficile à exposer clairement. C’est le cas ici, avec une approche confuse. Un exemple global appréhendé par morceau aurait aidé, ainsi qu’une explication de la cinématique globale. Suite des aspects avancés avec le chapitre 12 qui traite des différentes classes de fenêtres.

Les chapitres 13 et 14 nous ramènent à l’époque où l’on réinventait l’eau chaude en C++ à chaque librairie ! Voilà donc des objets de base pour gérer chaine de caractères, collections, fichiers, etc… Malheureusement toutes ces choses sont prises en paramètre par les API du framework…

Je passe sur le chapitre 15 qui décrit les facilités de debuggage et de gestion d’erreur et sur le chapitre 16 qui traite l’internationalisation très classiquement par le biais de ressources. Ces deux chapitres sont de toute façon assez courts. Plus intéressant, les chapitres 17 et 18 se focalisent sur des aspects systèmes : les threads et les sockets, prenant en charge ce que ACE fait en cross plateforme par exemple. On aime ou pas, mais wxWidgets permet de traiter ces aspects évènements de ces deux sous-systèmes dans sa boucle d’événement. Personnellement, j’aime pas !

Il est curieux qu’il faille attendre le chapitre 19 pour voir décrit le modèle « document – vue » de wxWidgets ! Il aurait dû être présenté bien avant. Quoi qu’il en soit, les auteurs proposent ici une approche par étape qui tranche un peu sur ce qui est fait par ailleurs dans le livre, et c’est une bonne nouvelle.

L’ouvrage se conclut par un chapitre 20 « perfecting your application » qui est un melting pot de différents sujets sans rapports les uns avec les autres.

Il faut voir les choses en face : il n’y a pas le choix de livres sur wxWidgets. C’est le seul. En terme de ciblage il se cherche un peu. Il voudrait être l’introduction à la programmation avec wxWidgets comme l’était le Petzold pour Windows mais tombe souvent dans le travers du manuel de référence sans en avoir la qualité. Ce n’est pas le Petzold non plus, c’est certain. Bref ce n’est pas un livre que je pourrais conseiller les yeux fermés, mais il n’est pas écrit avec les pieds non plus.

Plutôt vide, avec beaucoup de déclarations d’intention mais peu de concret.

Bref, un livre qui est loin d’être indispensable.

image

Référence complète : Cross-Platform GUI Programming with wxWidgets – Julian Smart and Kevin Hock with Stefan Csomor – Prentice Hall 2006 – ISBN : 9780131473812

Cross-Platform GUI Programming with Wxwidgets

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

Note de lecture : Applied C++, par Philip Romanik & Amy Muntz

Note: 4 ; Tutorial pour C++

A l’origine, j’avais classé cet ouvrage dans la partie « C++ avancé », à l’image de la plupart des ouvrages de cette série. Toutefois, au final cet ouvrage s’adresse d’avantage aux développeurs peu expérimentés, ce qui justifie ce classement.

Le livre compte un peu plus de 300 pages et presque 20 pour les annexes. Il n’est découpé qu’en 8 chapitres. Passons rapidement sur l’introduction de 7 pages nous dispensant quelques rudiments de traitement d’image et de principes de conception de système. Le second chapitre est à peine plus long avec 11 pages. Mais on commence à écrire quelques classes simples et à aborder les conseils proposés par les auteurs, essentiellement concernant les questions de constructeur, destructeur et opérateur d’affectation.

Les choses sérieuses commencent au chapitre 3 qui comprend 48 pages. On commence par une idée curieuse : réécrire l’allocation mémoire ! Rapidement, on y mélange beaucoup d’aspects : les templates, les destructeurs virtuels, etc… Difficile de s’y retrouver. On finit même par perdre de vue l’étude de cas !

Le chapitre 4 est long de 45 pages. On commence par y parler convention de style (nommage, indentation, etc…) pour ensuite parler réutilisation. Car on va réimplémenter des classes telles que std ::string, eh oui ! Tout le propos sur le support de debuggage a le mérite d’être original et intéressant. Même si aujourd’hui on s’appuie d’avantage sur les tests unitaires.

55 pages sont consacrées aux considérations système au chapitre 5. La façon dont les sujets sont abordés me laisse dubitatif : est-on en train de construire un framework système, là où la librairie standard ou ACE font un excellent travail ? Par exemple, les auteurs s’efforcent de reconstruire une classe thread en s’appuyant sur Posix, sur Unix et Windows. Non seulement ACE fait déjà cela, mais cette approche n’est pas la bonne sous Windows ! De même les auteurs nous invitent-ils à avoir notre propre classe de base apException ou notre propre gestion de l’internationalisation, là où la librairie standard a ce qu’il faut ! Troublant…

Avec 75 pages, le chapitre 6 « implémentation considérations » est le plus volumineux du livre ! Au moins a-t-il du sens, car les auteurs y développent un framework de gestion d’image. Si le propos est abondamment illustré, le fil un peu décousu ne facilite pas le suivi de celui-ci.

La chapitre 7 aborde les tests de performance. Mais disons le tout net : en 20 pages, on est surtout frustré par l’aspect superficiel du propos. Les auteurs en profitent pour nous présenter leur framework de tests unitaires. Aujourd’hui, cppUnit fait un meilleur travail.

Les sujets avancés traités en 35 pages dans le dernier chapitre vont un peu dans tous les sens : gestion mémoire, gestion du cache ou utilisation du mot clé « explicit »… Difficile de trouver un fil conducteur dans tout cela ! Et rien n’est vraiment traité de manière satisfaisante.

Il y a du bon et du moins bon dans ce livre.

Le bon, c’est que cet ouvrage décrit et adresse nombre de problématiques que l’on rencontre vraiment quand on développe du C++, plutôt que de s’appuyer simplement sur des cas d’école comme on le voit souvent. L’ensemble du livre s’appuie sur une véritable application, et son développement tire avantage des conseils dispensés par John Lakos dans son « Large scale C++ Design ».

Le moins bon, c’est nombre de conseils pour le moins curieux dispensés au long de l’ouvrage. On est même en droit parfois de se questionner sur le niveau de maîtrise du C++ des auteurs ! Pourquoi recommander l’usage des préfixes au lieu des namespaces ? Pourquoi s’évertuer d’utiliser un sous-ensemble de la STL et exhiber fièrement l’utilisation d’un conteneur inadapté ?

Ce livre est un « cas d’utilisation », mais l’étude de celui-ci occupe une place prépondérante dans le texte. Cela signifie que l’un des sujets principaux du livre est bel et bien le traitement d’images. Si ce n’est pas un sujet d’intérêt pour vous, vous risquez d’être carrément frustré ! Pour le moins, il faut bien savoir à quoi l’on a à faire.

Il n’en reste pas moins qu’un certain nombre d’idées et d’outils, pour les tests et les tests unitaires peuvent servir. Mais c’est quand même bien décevant…

image

Référence complète : Applied C++, Practical techniques for building better Software – Philip Romanik & Amy Muntz – Addison Wesley / C++ In depth series 2003 – ISBN: 0-321-10894-9

Applied C++: Practical Techniques for Building Better Software [With CDROM]

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

Note de lecture : The C++ Answer Book, par Tony L. Hansen

Note : 6 ; Un compagnon de route au Stroustrup.

Il s’agit, comme son titre l’annonce d’un livre d’exercices corrigés. Aujourd’hui c’est un texte fort ancien. Ancien peut-être, mais volumineux, certainement. On en prend pour 520 pages sur 8 chapitres seulement, sans compter les annexes ! Voyons ce qu’il a dans le ventre.
On passera rapidement sur le 1er chapitre qui est introductif (5 pages) pour nous tourner vers le 2nd qui traite des déclarations et des constantes. Les exercices sont tous très simples, c’est aussi l’occasion d’évoquer des éléments connexes à la questions en plus de répondre à celle-ci.

Si le chapitre 2 ne comptait qu’une trentaine de pages, c’est près de cinquante que nous offre le chapitre 3 dédié aux expressions. On y a droit inévitablement aux ordres d’évaluation de expressions, mais aussi aux comportements « limite » du langage, y compris à ceux causant des problèmes de portabilité. Une partie significative du chapitre est dédié à la manipulation de chaine de caractères, à l’ancienne façon « C ». Le niveau de difficulté augmente significativement, il était au maximum à 1.5 au chapitre 1, il monte ici à 2.5 selon l’échelle exponentielle de l’auteur ! La dimension algorithmique des exercices n’est pas triviale. De quoi se rafraichir les neurones !

Au chapitre 4, on évoque les fonctions et les fichiers. Du moins c’est ce que dit le titre. 60 pages sont consacrées à cette partie qui, en fait a surtout trait à la manipulation de structures : listes, graphes ou tableaux bi-dimensionnels avec les inévitables tris et manipulation. On parle en fait assez peu de fichiers et si on évoque les différences entre C et C++, cela reste du code à affinité C. Bien sûr, le niveau de difficulté augmente sensiblement et culmine à 3.

Le chapitre 5 marque notre véritable entrée dans le C++ car il y est question de classes ! Transition en douceur, car les premiers exercices font suite au chapitre précédent et l’on commence par faire des classes avec des struct ! D’un point de vue utilisation du langage, les 80 pages de ce chapitre restent dans la simplicité. Finalement on travaille surtout à encapsuler la complexité algorithmique dans des classes, ce qui n’est pas si mal. D’un point de vue conception, l’exercice le plus complexe est l’implémentation d’un interpréteur d’expressions à l’aide d’un pattern composite (l’un de mes exercices préféré).

Il me semble assez curieux que le chapitre suivant soit consacrée à la surcharge d’opérateur, car il ne m’a jamais semblé que ce soit une fonctionnalité fondamentale. On trouve quand même 125 pages à lui consacrer ! On commence à rentrer dans le dur du comportement du langage. Il est d’ailleurs troublant de constater que la notion de référence est abordée ici chemin faisant… La classe LINT (large int) nous occupe pas mal de temps, notamment pour comprendre les comportements au limite du langage. Après avoir plafonné à 3 au chapitre précédent, le niveau de difficulté culmine à 4.

Ce sont 90 pages qui sont dédiés à la question des classes dérivées dans cet avant-dernier chapitre. L’exercice sur la classe process nous vaut le niveau de difficulté maximum, mais le chapitre me semble globalement simple. Si on y trouve de l’héritage privé (une fonctionnalité dont l’usage est rare), ainsi que des enum et des classes « friend », nulle trace d’héritage multiple et d’héritage virtuel ! Mais je ne dois pas oublier que le livre date de 1990…

Le dernier chapitre est consacré aux streams. Un sujet souvent bien mal traité. Ici ce sont 90 pages qui lui sont consacrées. Après un démarrage en douceur on aborde vite des exercices compliqués comme l’implémentation de la librairie IO C en C++ et vice-versa !

Les exercices traitant des parties cœur du langage sont toujours valables, ils mériteraient une réactualisation par rapport à la librairie standard, bien sûr. C’est donc un bon bouquin pour solidifier les bases.

Les exercices sont souvent courts et les explications précises. Les plus complexes nécessitent qu’on leur consacre beaucoup, beaucoup de temps ! Par bien des côtés, je retrouve là l’approche du Kernighan & Ritchie. Avec 550 pages il est quand même moins digeste que son aîné. De fait, c’est plutôt un texte dans lequel aller picorer des exercices, plus qu’à être lu de bout en bout ! Le texte fait référence au Stroustrup orignal (1er édition) que je ne possède pas, ayant débuté avec la seconde édition en français.

image

Référence complète : The C++ Answer Book – Tony L. Hansen – Addison Wesley 1990 – ISBN : 0-201-11497-6

The C++ Answer Book

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

Note de lecture : La bibliothèque standard STL du C++ – Alain-Bernard Fontaine – InterEditions 1997 – ISBN : 2-7296-0657-2

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 !

Le chapitre 5 nous parle de gestion mémoire et des classes l’implémentant dans la librairie C++. Le propos tourne autour des modèles mémoire de Windows (car le livre évoque beaucoup Visual C++ 4.2) et les auto_ptr de la librairie qui ne sont pas utilisables avec la STL. Tout cela n’a donc aucun intérêt par rapport à la STL. Passons.

Le reste des chapitres (du 6 au 16) présente les différents conteneurs de la librairie, les itérateurs et les algorithmes. Un très long chapitre est d’ailleurs consacré aux algorithmes, le seul où l’auteur a (vainement) essayé de faire un effort rédactionnel. Les autres chapitres sont une version dégradée de l’information de base disponible avec les headers, agrémenté d’exemples hermétiques.

Il est réellement étonnant qu’un éditeur ayant pignon sur rue ait pu laisser passer un texte d’une telle médiocrité. Il est vrai que la bibliographie française ne présentait pas à l’époque une quelconque concurrence, mais à un certain niveau, il est préférable de ne rien éditer que de publier une merde (vous avez bien lu). Pour couronner le tout, l’impression et la reliure sont de médiocre qualité. Même gratuit, ce livre serait encore trop cher. Ne perdez pas votre temps à le feuilleter chez votre libraire.

image

Référence complète : La bibliothèque standard STL du C++ – Alain-Bernard Fontaine – InterEditions 1997 – ISBN : 2-7296-0657-2

La bibliothèque standard STL du C


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

Note de lecture : Langage C++ seconde édition, par Nino Silverio

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.

Le troisième chapitre couvre 110 pages et aborde justement les classes. D’abord les éléments de base, puis très rapidement les templates. C’est même un peu déroutant. La surcharge d’opérateur et la sérialisation pour les streams déboulent un peu n’importe comment là-dedans. J’allais dire que j’étais content de ne pas avoir débuté avec cet ouvrage, mais en fait j’ai commencé avec le Stroustrup. Ce n’est pas prouvé que ce soit tellement mieux… Ca se poursuit avec la constance, les namespaces, etc… Tout cela est terriblement confus et à mon avis relatif à ce découpage pas très raisonnable en chapitres d’une centaine de pages.

Le 4ème chapitre traite de la programmation orientée objet en C++. C’est le dernier chapitre, on en prend pour 140 pages : on va s’amuser ! On commence par parler d’héritage, de classe et de polymorphisme (encore cette confusion entre orienté-objet et polymorphisme…). On parle aussi de visibilité. Bien sûr on en a déjà parlé dans le volume (pardon, le chapitre) précédent, mais là on a les éléments pour en comprendre l’utilité. Les exemples ne sont pas bluffant. L’utilisation d’une classe « Generique » comme illustration d’une classe de base abstraite est à mon avis un gros ratage. Les exemples sont aussi trop longs et trop complexe. L’héritage multiple est assimilé à de l’héritage « en diamant » de quoi donner des arguments aux détracteurs !

Le bouquin fait certainement le boulot, on a vu pire à cet égard. Mais il n’est pas engageant et on ne l’abordera pas pour le plaisir. Les exemples sont souvent complexes, obscurcissant le focus qui devrait être sur le langage pour comprendre l’algorithmique (cf. les arbres binaires). Le langage a bien évolué depuis, sans même parler de la norme C++ 11, c’est donc fort logiquement qu’on le jugera maintenant obsolète.

Référence complète : Langage C++ seconde édition, passage du C au C++ et programmation orientée objet – Nino Silverio – Eyrolles 1993 – ISBN : 978212088588

Langage C++, passage du C au C++ et programmation orientée objet

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

Note de lecture : C++ Programming style, par Tom Cargill

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.

C++ Programmin Style

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

C++ Programming Style


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