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

Publicités

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