Note : 5 ; Une introduction au C++ 2011, qui se lit mieux si on comprend déjà quelque peu le langage…

Une mise à jour de mes connaissances sur les dernières évolutions du langage : voilà ce qui étaient mes attentes concernant ce livre. Un livre fort court avec seulement 170 pages, ce qui me convenait parfaitement. D’ailleurs quand je dis « dernières évolutions du langage », c’est une façon de parler : j’ai bien attendu l’année de la norme 2017 pour lire un livre sur la norme 2011…

Le texte est bien découpé : les 170 pages sont réparties en 14 chapitres, chacun adressant un thème particulier du langage. Le premier couvre les « basics » sur 14 pages, j’y apprends quand même plusieurs nouveautés : le nullptr qui remplace null et la syntaxe for range permettant l’itération implicite sur des containers, comme en Java. Mais aussi l’inférence de types avec auto et l’initialisation des variables avec les accolades au lieu des parenthèses (on continue par ailleurs à utiliser celles-ci, tout n’est pas clair…). De petites (et moins petites) choses, mais de bonnes choses. Seulement 6 pages pour les « User defined types » du chapitre 2. Il faut dire que l’on n’a pas encore abordé les classes. Ici la nouveauté réside dans les class enums qui permet de typer ceux-ci. Là aussi on se rapproche du Java, mais sans pour autant pouvoir faire autant de choses avec. Dommage d’y consacrer moins d’une demi-page.

Le chapitre 3 a pour thème la modularité. Rien de bien nouveau là-dedans : compilation séparée avec le header et le body, bien sûr on y évoque les namespaces mais aussi les exceptions où réside l’une des deux nouveautés pour ce chapitre : le noexcept (j’apprendrais aussi plus tard que là très controversée clause throw sur les méthodes est désormais dépréciée). L’autre nouveauté, c’est le static_assert sur lequel une nouvelle fois, l’auteur ne s’étend guère. Les choses très sérieuses arrivent au chapitres 4 : les classes, qu’elles soient concrètes ou abstraites. J’y retrouve ce que je connais. L’auteur y mélange joyeusement un propos lié aux conteneurs (les vecteurs pour être précis) : on reconnait Stroustrup, la confusion, c’est un peu sa marque de fabrique ! Parmi les nouveautés, l’overriding explicite (comme en Java) qui clarifie et sécurise bien le code. Avec la même syntaxe dans la signature de méthode, on trouve default et delete, le premier évitant de redéfinir les constructeurs et opérateurs d’affectations standard dans le cas où leur génération implicite est désactivée. Le second permet de désactiver les mêmes constructions sans avoir à utiliser l’idiome de Scott Meyers : un soulagement. Le gros de la troupe vient du move operator. Là il y a du lourd, l’auteur manque à nouveau de clarté et il faudra que je revienne là-dessus !

Au chapitre 5 on attaque aussi un gros morceau : les templates. Deux nouveautés pour moi ici : Les lambda expressions, qui là encore vont nécessiter un peu de travail pour bien comprendre la mécanique d’appel, et les variadics, une fonctionnalité vraiment avancée qui signe l’accueil dans le langage du template metaprogramming !

Avec le chapitre 6, on attaque la librairie standard. Le chapitre 6, justement ne fait que 3 pages et sert juste de table des matières. Passons ! Le chapitre 7 aborde les strings et les expressions régulières. Ces dernières ne faisaient pas encore partie de la librairie standard, mais je n’y vois pas de surprises. Les iostreams du chapitre 8 n’ont pas non plus changé. C’est généralement une partie de la librairie difficile à bien comprendre t contrairement à son habitude, l’auteur fait un bon travail d’introduction.

Les containers abordés au chapitre 9 ont un peu changé, car on a désormais des versions « unordered » de ceux-ci pour différentier les containers arbres des hashsets. L’auteurs n’est pas extraordinairement clairs en abordant ces différents conteneurs, heureusement qu’il figure un tableau récapitulatif ! Au chapitre 10, on est toujours dans la STL, avec les algorithmes et les iterators. Si l’auteur regrette que la notion de « concept » ne figure pas encore dans le langage, je regrette pour ma part que rien ne soit dit sur les différents types (ou concepts, justement) d’itérateurs…

Au chapitre 11 on revient sur certains utilitaires : pair est déjà bien connu et tuple (qui généralise pair) est d’un emploi complexe, car il s’appuie sur des variadics. L’un des aspects importants de ce chapitre est unique_ptr et shared_ptr pour gérer les ressources. Exit donc le pas terrible auto_ptr ! Les binders de fonctions ferment ce chapitre, leur description étant un peu limite, comme souvent, hélas ! Le chapitre 12 consacré aux numerics est très, très court. Je passe.

L’avant-dernier chapitre est une toute nouvelle partie de la librairie standard : elle aborde les objets de gestion de la concurrence ! On y trouve des choses qui figuraient précédemment dans la boost. La plupart des concepts ne sont guère nouveaux, à l’exception certainement des promises et des futures.

Le livre se referme sur un chapitre 14 dédié à l’historique et à l’évolution du langage : agréable à lire il est aussi précieux pour moi pour résumer ce qui est nouveau et ce qui est déprécié.

Bjarne Stroustrup n’est pas un grand écrivain, il le prouve encore avec un livre qui doit être particulièrement difficile pour qui ne connait pas le langage. Le même ouvrage écrit par Stanley Lippmann aurait une autre gueule. Mai pour moi, il fait globalement le boulot. A noter aussi la section « advice » en fin de chaque chapitre qui guide plutôt bien le lecteur sur l’usage du langage.

Référence complète : A Tour of C++ – Bjarne Stroustrup – Addison Wesley / C++ in Depth series 2014 – ISBN: 978 0 321 95831 0